SwiftGUI 0.11.18__tar.gz → 0.11.20__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SwiftGUI
-Version: 0.11.18
+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.18 → swiftgui-0.11.20}/pyproject.toml

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

{swiftgui-0.11.18 → 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
+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.
@@ -59,11 +59,11 @@ class BaseElement(_BaseSharedAttributes):
     The different to BaseWidget is that BaseWidget is designed for a single tk-Widget.
     BaseElement allows you to do whatever the f you want, it's just a class pattern.
     """
-    parent:Self = None  # next higher Element
-    _fake_tk_element:tk.Widget = None   # This gets returned when parent is None
-    _element_flags:set[ElementFlag] # Properties the element has
+    parent: Self = None  # next higher Element
+    _fake_tk_element: tk.Widget = None   # This gets returned when parent is None
+    _element_flags: set[ElementFlag] # Properties the element has
 
-    defaults:type[GlobalOptions.DEFAULT_OPTIONS_CLASS] = GlobalOptions.EMPTY  # Change this to apply a different default configuration
+    defaults: type[GlobalOptions.DEFAULT_OPTIONS_CLASS] = GlobalOptions.EMPTY  # Change this to apply a different default configuration
 
     # So you can use it on inheriting classes without importing it
     _run_after_window_creation = run_after_window_creation
@@ -73,6 +73,7 @@ class BaseElement(_BaseSharedAttributes):
         self._run_when_window_exists = list()
 
         self._update_options = dict()   # This saves all valuew passed by .update, so they can be recalled using .get_option()
+        self._is_used_up: bool = False  # True, if self._init ran at least once, indicating that this element was part of a window once
 
     def _init(self,parent:"BaseElement",window):
         """
@@ -84,6 +85,10 @@ class BaseElement(_BaseSharedAttributes):
         :param window: Main Window
         :return:
         """
+        if self._is_used_up:
+            raise ReuseError(f"Element was used in a window multiple times: {repr(self)}")
+        self._is_used_up = True
+
         self._init_defaults()   # Default configuration
         self._flag_init()
 
@@ -91,7 +96,7 @@ class BaseElement(_BaseSharedAttributes):
         self._personal_init()
 
         self._apply_update()
-        self.add_flags(ElementFlag.IS_CREATED)  # Todo: Check if this is okay. It was behind self._flag_init() before.
+        self.add_flags(ElementFlag.IS_CREATED)
         #element_logger.debug(f"Initialized {repr(self)} in {window}")
 
     def _flag_init(self):
@@ -378,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
@@ -766,6 +817,21 @@ class BaseWidgetContainer(BaseWidget):
         self._line_insert_kwargs = dict()
         self.add_flags(ElementFlag.IS_CONTAINER)
 
+    def _row_iter_to_list(self, row: Iterable[BaseElement | None]) -> list[BaseElement | None]:
+        """
+        Convert a row to a list.
+        If the row can't be converted, a RowTypeError is raised
+        :param row:
+        :return:
+        """
+        try:
+            return list(row)
+        except TypeError:
+            raise RowTypeError("\n\nA row in one of your layouts is not a row.\n"
+                               "\n"
+                               f"This... {repr(self)}\n\n"
+                               f"Contains this (should be a row)... {repr(row)}")
+
     def update_all_containing(self, **kwargs) -> Self:
         """
         Update all elements inside this frame

{swiftgui-0.11.18 → swiftgui-0.11.20}/src/SwiftGUI/BasePopup.py

@@ -1,11 +1,11 @@
 import io
-from collections.abc import Iterable
 from os import PathLike
-from typing import Hashable, Any, Literal
+from typing import Hashable, Any, Literal, Generic, Iterable
+from typing_extensions import TypeVar
 from PIL import Image
 
 import SwiftGUI as sg
-from SwiftGUI import Color, ValueDict
+from SwiftGUI import Color, ValueDict, ReuseError
 from SwiftGUI.Compat import Self
 
 class BasePopupNonblocking:
@@ -67,12 +67,14 @@ class BasePopupNonblocking:
         """
         ...
 
-class BasePopup(BasePopupNonblocking):
+return_type = TypeVar("return_type", default=Any)
+
+class BasePopupTyped(BasePopupNonblocking, Generic[return_type]):
     def __init__(
             self,
             layout: Iterable[Iterable[sg.BaseElement]],
             *,
-            default: Any = None,     # Returned instead of None
+            default: return_type = None,     # Returned instead of None
             keep_on_top: bool = True,
             title: str = None,
             titlebar: bool = None,
@@ -86,6 +88,7 @@ class BasePopup(BasePopupNonblocking):
 
         self._return = None
         self._default = default
+        self._used_up = False
 
         super().__init__(
             layout,
@@ -100,13 +103,7 @@ class BasePopup(BasePopupNonblocking):
             **kwargs,
         )
 
-    def __new__(cls, *args, **kwargs) -> Any:
-        me = super().__new__(cls)
-        me.__init__(*args, **kwargs)
-
-        return me() # Run the popup and return the result
-
-    def done(self, val: Any = None):
+    def done(self, val: Any = None) -> return_type:
         """
         Call this instead of return.
         The popup will close and return_value is returned.
@@ -116,7 +113,7 @@ class BasePopup(BasePopupNonblocking):
         self._return = val
         self.w.close()
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args, **kwargs) -> return_type:
         """
         Execute the popup-functionality.
         YOU DON'T NEED TO CALL THIS!
@@ -125,9 +122,22 @@ class BasePopup(BasePopupNonblocking):
         :param kwargs:
         :return:
         """
+        if self._used_up:
+            raise ReuseError("You cannot re-open popup-instances. Create a new instance to re-use the popup.")
+        self._used_up = True
+
         self.w.block_others_until_close()
 
         if self._return is None:
             return self._default
 
         return self._return
+
+class BasePopup(BasePopupTyped, Generic[return_type]):
+
+    def __new__(cls, *args, **kwargs) -> return_type:
+        me = super().__new__(cls)
+        me.__init__(*args, **kwargs)
+
+        return me() # Run the popup and return the result
+

{swiftgui-0.11.18 → 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.18 → swiftgui-0.11.20}/src/SwiftGUI/Canvas_Elements/_Base.py

@@ -200,4 +200,4 @@ class BaseCanvasElement(sg.BaseWidget): # Inheritance mainly for the update-rout
         return self._unflatten(self.canvas.tk_widget.bbox(self.canvas_id))
 
     def __repr__(self):
-        return f"<sgc.{self.__class__.__name__} element at {id(self)}>"
+        return f"<sgc.{self.__class__.__name__} canvas-element with key={self.key} at {id(self)}>"

{swiftgui-0.11.18 → 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.18 → swiftgui-0.11.20}/src/SwiftGUI/Combined_Elements/Console.py

@@ -14,6 +14,7 @@ class Console(sg.BaseCombinedElement):
             *,
             key: Hashable = None,
             key_function: Callable | Iterable[Callable] = None,
+            input_text_color: str | sg.Color = None,
             default_event: bool = False,
             input_prefix: str = None,
             print_prefix: str = None,
@@ -54,6 +55,7 @@ class Console(sg.BaseCombinedElement):
             add_timestamp = add_timestamp,
             width = width,
             height = height,
+            input_text_color=input_text_color,
         )
 
     def _get_value(self) -> Any:
@@ -86,6 +88,16 @@ class Console(sg.BaseCombinedElement):
                 self._print_prefix = new_val
             case "add_timestamp":
                 self._add_timestamp = new_val
+            case "input_text_color":
+                if new_val is None:
+                    return True
+
+                if self.window is None:
+                    self.update_after_window_creation(input_text_color = new_val)
+                    return True
+
+                self.textField.tk_widget.tag_config("input", foreground=new_val)
+
             case _: # No other case covered this key, so let's let's the parent-class handle the rest
                 return super()._update_special_key(key, new_val)
 
@@ -138,23 +150,24 @@ class Console(sg.BaseCombinedElement):
         """
         self._prev_value = text
 
-        text = self._input_prefix + text
-
         if self._add_timestamp:
-            text = self.get_time() + text
+            self.append(self.get_time() + " ", add_newline=False)
+
+        self.append(self._input_prefix, add_newline=False)
 
-        self.append(text + "\n", add_newline= False)
+        self.append(text + "\n", add_newline= False, tag="input")
 
         return self
 
-    def append(self, text: str, add_newline: bool = True) -> Self:
+    def append(self, text: str, add_newline: bool = True, tag: str = None) -> Self:
         """
         Just append to the text-field, nothing more, nothing less
         :param add_newline: True, if \n should be appended too
         :param text:
+        :param tag: tkinter-tag
         :return:
         """
-        self.textField.append(text, add_newline=add_newline)
+        self.textField.append(text, add_newline=add_newline, tags=tag)
         self.textField.see_end()
         return self
 

{swiftgui-0.11.18 → 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.18 → swiftgui-0.11.20}/src/SwiftGUI/Compat.py

@@ -35,5 +35,3 @@ else:
 
         if collected:
             yield tuple(collected)
-
-

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

@@ -97,6 +97,19 @@ def preview_all_elements(
             sg.FileBrowseButton("save_single", file_browse_type="save_single", disabled= flip_disabled),
             sg.FileBrowseButton("open_multiple", file_browse_type="open_multiple", disabled= flip_disabled),
             sg.FileBrowseButton("open_directory", file_browse_type="open_directory", disabled= flip_disabled),
+        ],[
+            sg.HSep(),
+            sg.Spacer(height=10),
+        ], [
+            sg.T("sg.PythonConsole, works with the normal print and input functions:"),
+        ],[
+            sg.PythonConsole(width=50, height=10),
+        ],[
+            sg.Spacer(height=5),
+        ], [
+            sg.T("See for yourself:  "),
+            sg.Button("print('Hello World')", key_function=lambda: print("Hello World")),
+            sg.Button("input('Your input: ')", key_function=lambda: input("Your input: ")),
         ]
     ], fake_key= "Extended elements")
 
@@ -152,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)
@@ -161,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"))
         ]
@@ -212,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()
@@ -245,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()
@@ -305,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",
@@ -388,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(...)")