easykinter 0.0.1__tar.gz

easykinter-0.0.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: easykinter
+Version: 0.0.1
+Summary: A wrapper to make Tkinter 90% less boring.
+Author-email: Starly <starly.alt.acc1@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pillow>=10.0.0

easykinter-0.0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "easykinter"
+version = "0.0.1"
+authors = [
+  { name="Starly", email="starly.alt.acc1@gmail.com" },
+]
+description = "A wrapper to make Tkinter 90% less boring."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = ["pillow>=10.0.0"]
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: Microsoft :: Windows",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

easykinter-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

easykinter-0.0.1/src/easykinter/EasyKinter.py

@@ -0,0 +1,932 @@
+import tkinter as tk
+import warnings as warn
+from PIL import Image as img, ImageTk as imgtk
+import atexit as _atexit
+
+#region all the nice and dandy EasyKinter functions
+
+#region Code that Automatically Runs mainloop() DO NOT TOUCH
+#verifying if mainloop was called
+_MainloopCalled = False
+_OriginalMainloop = tk.Tk.mainloop
+
+def _newmainloop(self, n=0):
+    global _MainloopCalled
+    _MainloopCalled = True
+    return _OriginalMainloop(self, n)
+
+tk.Tk.mainloop = _newmainloop
+
+#now call the function if mainloop wasn't written, and we're good to go.
+def _auto_run():
+    global _MainloopCalled
+    if not _MainloopCalled and hasattr(tk, "_default_root") and tk._default_root:
+        try:
+            tk._default_root.mainloop()
+        except Exception:
+            pass
+_atexit.register(_auto_run)
+#hell yeah.
+#endregion
+
+#region Create Root Window Function
+def CreateRoot(Title="Root Tkinter Window", SizeX=250, SizeY=250, PosX=None, PosY = None, HideWindow=False):
+    """
+    # This function creates a new Root window and returns the value of the fully created window when done.
+
+    **Title** = What the Tk window's name will be upon creation.
+
+    **Geometry Configs**:
+        SizeX = Dictates the width of your window.
+        SizeY = Dictates the height of your window.
+
+        PosX = Position in your screen where the window is created, cannot be higher than the size of your monitor. (Width)
+        PosY = Position in your screen where the window is created, cannot be higher than the size of your monitor. (Height)
+
+    **Extra**:
+        HideWindow = Tells the program if your window will be hidden upon creation.
+    """
+    
+    if tk._default_root is not None:
+        raise RuntimeError(f"Root window could not be created as a root instance already exists.")
+
+    else:
+        newRoot = tk.Tk()
+        newRoot.title(Title)
+        newRoot.geometry(f"{SizeX}x{SizeY}{f'+{PosX}' if PosX is not None else ''}{f'+{PosY}' if PosY is not None else ''}")
+
+        if HideWindow:
+            newRoot.withdraw()
+    newRoot.update_idletasks()
+    
+    return newRoot
+# endregion
+
+#region Create Toplevel Window Function
+def CreateToplevel(Title="Toplevel Tkinter Window", Parent=None, Child=None, SizeX=250, SizeY=250, PosX=None, PosY=None):
+    """
+    # This function creates a new Toplevel window and returns the value of the fully created window when done.
+
+    **Title** = What the TopLevel window's name will be upon creation.
+    
+    **Geometry Configs**:
+        SizeX = Dictates the width of your window.
+        SizeY = Dictates the height of your window.
+
+        PosX = Position in your screen where the window is created, cannot be higher than the size of your monitor. (Width)
+        PosY = Position in your screen where the window is created, cannot be higher than the size of your monitor. (Height)
+
+    **Extra**:
+        Parent = Tells the program what parent this toplevel window will have. This can greatly affect the window's behavior.
+    """
+
+    WindowName = tk.Toplevel(Parent)
+    WindowName.title(Title)
+    WindowName.geometry(f"{SizeX}x{SizeY}{f'+{PosX}' if PosX is not None else ''}{f'+{PosY}' if PosY is not None else ''}")
+
+    if Child is not None:
+        if not isinstance(Child (tk.Toplevel, tk.Tk)):
+            raise ValueError(f"Could not link {WindowName} with {Child} as {Child} is not a Toplevel or Tk window. Did you try checking the 'Child=' value?")
+
+        else:
+            Child.transient(WindowName)
+    WindowName.update_idletasks()
+
+    return WindowName
+#endregion
+
+#region W.I.P Customization Function
+def ExtraCustomize(TargetWindow, background="#f0f0f0", hideTitleBar=False, ResizableWidth=None, ResizableHeight=None):
+    """
+    # (W.I.P) This function allows you to fully customize and color any window you want.
+
+    **TargetWindow** = The name of the window or widget that will be targetted.    
+
+    **Coloring Configs:**
+        background = What the color of the widget's background will be set to.
+
+    **Extra:**
+        hideTitleBar = Will apply overridedirect(True) to window if value is set to true.
+        ResizableWidth = Dictates wether your window can be resized horizontally.
+        ResizableHeight = Dictates if your window can be resized vertically.
+    """
+
+    if TargetWindow is None:
+        raise ValueError(f"Expected a Tkinter window/frame, but got None instead.")
+     
+    elif not isinstance(TargetWindow, (tk.Tk, tk.Toplevel)):
+        raise TypeError(f"Expected a Tkinter window, but got {type(TargetWindow).__name__} instead.")
+    
+    else:
+        TargetWindow.configure(bg=background)
+
+        if hideTitleBar:
+            TargetWindow.overrideredirect(True)
+    
+    if ResizableHeight is not None or ResizableWidth is not None:
+        if isinstance(TargetWindow, (tk.Tk, tk.Toplevel)):
+            TargetWindow.resizable(ResizableWidth, ResizableHeight)
+        
+        else:
+            warn.warn(f"Resize attributes were skipped as the target was a '{type(TargetWindow).__name__}' and it cannot have a Resizeable attrbute. Have you tried using tk.Toplevel or tk.Tk?", category=RuntimeWarning)
+#endregion
+
+#region Creating Customizeable Labels and Auto-Pack Function
+def CreateLabel(ForWindow, Text="New Label", font="Arial", FontSize=12, LabelImage=None, ImageCompound="Center", optionalCustomization = "", BgColor="#f0f0f0", FgColor="#000000", PackType=None, Anchor="center", PadX=0, PadY=0, Side=tk.TOP, Row=0, Column=0, Sticky=None, X=None, Y=None, RelX=None, RelY=None):
+    """
+    # This function creates and returns a custom label that can be also packed within the same function.
+
+    **ForWindow** = This dictates that target where the label will be created for.
+
+    **Formatting:**
+        text = What text the label will contain.
+        font = What custom font the label will use.
+        FontSize = The size of the font used.
+        OptionalCustomization = Dictates special font formatting such as bold, italic, or underline.
+            (Options: 'bold', 'italic', 'underline', 'overstrike')
+        LabelImage = What custom image the label will have. (Must be a tk.PhotoImage object.)
+        ImageCompound = What direction the image will be placed on top of the text.
+            (Options: 'top', 'left', 'center',  'right', 'bottom', 'none')
+
+    **Extra Customization:**
+        BgColor = What the background of the label will be colored as.
+        FgColor = The color of the text within the label.
+        Anchor = Where the text will be anchored, affects where it will be packed.
+    
+    # Packing Types and their parameters:
+
+    **Pack (The default type, packs label and contains borders.):**
+        PadX = Width for the padding of the label.
+        PadY = Height for the padding of the label.
+        Side = Side where the label will go to in the widget, is relative.
+        Sticky = Position where the label will stick to in the widget, is not relative.
+    
+    **Grid (for mounting grids and organized sheets):**
+        Row = The row where your element will be placed. (Horizontal)
+        Column = the column where your element will be placed. (Vertical)
+        PadX = the padding width your element will have, affects elements in and outside of the grid.
+        PadY = the padding height your element will have, affects elements in and outside of the grid.
+    
+    **Place (for accurately placing elements in absolute or relative positions):**
+        X = The absolute position of the element in your window, cannot be moved. (Width)
+        Y = The absolute position of the element in your window, cannot be moved. (Height)
+        RelX = The relative position of the element in your window, can be moved. (Width)
+        RelY = The relative position of the element in your window, can be moved. (Height)
+    """
+
+    if not isinstance(ForWindow, (tk.Tk, tk.Frame, tk.Toplevel)):
+        raise TypeError(f"Expected a Tkinter window/frame, but got {type(ForWindow).__name__} instead.")
+
+    if ImageCompound is not None:
+        ImageCompound = ImageCompound.lower()
+
+        if ImageCompound == "top":
+            ImageCompound = tk.TOP
+        
+        elif ImageCompound == "left":
+            ImageCompound = tk.LEFT
+        
+        elif ImageCompound == "center":
+            ImageCompound = tk.CENTER
+        
+        elif ImageCompound == "right":
+            ImageCompound = tk.RIGHT
+        
+        elif ImageCompound == "bottom":
+            ImageCompound = tk.BOTTOM
+
+    newLabel = tk.Label(ForWindow, image=LabelImage, compound=ImageCompound, text=Text, font=(font, FontSize, optionalCustomization), bg=BgColor, fg=FgColor)
+
+    if PackType is not None:
+        PackType = PackType.lower()
+
+    if PackType is not None and PackType not in ["place", "grid", "pack"]:
+        raise ValueError(f"Expected a proper packing style, but got {PackType} instead. Current packing types are 'Pack', 'Grid', or 'Place'")
+
+    elif PackType == "pack":
+        newLabel.pack(anchor=Anchor, padx=PadX, pady=PadY, side=Side, sticky=Sticky)
+    
+    elif PackType == "place":
+        newLabel.place(x=X, y=Y, relx=RelX, rely=RelY, anchor=Anchor)
+
+    elif PackType == "grid":
+        newLabel.grid(row=Row, column=Column, padx=PadX, pady=PadY)
+    
+    return newLabel
+#endregion
+
+#region Creating Text Entry Widget and Custom Keybinding Function
+def CreateEntry(ForWindow, CustomFunc=None, CustomFuncKeybind=None, PlaceHolderEnabled=True, PlaceHolderText="Insert text here...", PlaceHolderTextColor="Gray", Width=None, Font="Arial", FontSize=12, FontProperties=None, borderwidth=None, bg=None, fg="#000000", PackType=None, Anchor="center", PadX=0, PadY=0, Side=tk.TOP, Row=0, Column=0, Sticky=None, X=None, Y=None, RelX=None, RelY=None):
+    """
+    # This function automatically creates and customizes an Entry widget in tkinter. Can also additionally trigger a funtion or be automatically packed.
+
+    **Logic parameters:**
+        ForWindow = Defines the target window where the entry will be created.
+        CustomFunc = Sets a function to automatically trigger when the set keybind is activated. Must be added alongside **CustomFuncKeybind.**
+        CustomFuncKeybind = Sets a keybind for a function to trigger when entering said keybind in the entry widget. Must be added alongside **CustomFunc.**
+        PlaceHolderEnabled = Dictates wether the Entry widget will have a pre-built placeholder.
+        
+    **UX and Customization:**
+        PlaceHolderText = Defines what text will appear in the placeholder UI.
+        PlaceHolderTextColor = Defines what color of the placeholder text will be.
+        Width = Defines the width of the input box.
+        Font = Defines the custom font the text will have in the input.
+        FontSize: = Defines the size of the text in the Entry box. Also affects Entry box height.
+        FontPorperties = Wether a custom font property will be applied.
+            (Current properties availiable = 'Bold', 'Italic', 'Underline', 'Overstrike')
+        bg = What the background of the label will be colored as.
+        fg = The color of the text within the label.
+    
+    # Packing Types and their parameters:
+
+    **Pack (The default type, packs label and contains borders.):**
+        PadX = Width for the padding of the label.
+        PadY = Height for the padding of the label.
+        Side = Side where the label will go to in the widget, is relative.
+        Sticky = Position where the label will stick to in the widget, is not relative.
+    
+    **Grid (for mounting grids and organized sheets):**
+        Row = The row where your element will be placed. (Horizontal)
+        Column = the column where your element will be placed. (Vertical)
+        PadX = the padding width your element will have, affects elements in and outside of the grid.
+        PadY = the padding height your element will have, affects elements in and outside of the grid.
+    
+    **Place (for accurately placing elements in absolute or relative positions):**
+        X = The absolute position of the element in your window, cannot be moved. (Width)
+        Y = The absolute position of the element in your window, cannot be moved. (Height)
+        RelX = The relative position of the element in your window, can be moved. (Width)
+        RelY = The relative position of the element in your window, can be moved. (Height)    
+    """
+
+    def on_entry_click(event=None):
+        if NewEntry.get() == PlaceHolderText:
+            NewEntry.delete(0, tk.END)
+            NewEntry.config(fg=fg.lower())
+
+    def on_focus_out(event=None):
+        if not NewEntry.get():
+            NewEntry.insert(0, PlaceHolderText)
+            NewEntry.config(fg=PlaceHolderTextColor.lower())
+
+
+    NewEntry = tk.Entry(ForWindow, width=Width if Width is not None else 20, font=(Font.capitalize(), FontSize, FontProperties.lower() if FontProperties else "normal"), bg=bg, fg=fg, borderwidth=borderwidth if borderwidth is not None else 1)
+
+    if CustomFuncKeybind is not None and CustomFunc is not None:
+        def eventNeedlessFunction(event):
+            CustomFunc()
+
+        NewEntry.bind(CustomFuncKeybind, eventNeedlessFunction)
+    
+    elif CustomFuncKeybind is not None or CustomFunc is not None:
+        raise ValueError("The function could not be called as the Function Keybind values have not been filled properly. Did you try checking both 'CustomFunc__' values?")
+
+    if PlaceHolderEnabled:
+        NewEntry.bind("<FocusIn>", on_entry_click)
+        NewEntry.bind("<FocusOut>", on_focus_out)
+        on_focus_out()
+
+
+    if PackType is not None:
+        PackType = PackType.lower()
+
+    if PackType is not None and PackType not in ["place", "grid", "pack"]:
+        raise ValueError(f"Expected a proper packing style, but got {PackType} instead. Current packing types are 'Pack', 'Grid', or 'Place'")
+
+    elif PackType == "pack":
+        NewEntry.pack(anchor=Anchor, padx=PadX, pady=PadY, side=Side, sticky=Sticky)
+    
+    elif PackType == "place":
+        NewEntry.place(x=X, y=Y, relx=RelX, rely=RelY, anchor=Anchor)
+
+    elif PackType == "grid":
+        NewEntry.grid(row=Row if Row is not None else 0, column=Column if Column is not None else 0, padx=PadX, pady=PadY)
+
+    return NewEntry
+#endregion
+
+#region Creating Button Widget and Custom Keybinding Function
+def CreateButton(ForWindow, Text="New Button", Image=None, Compound="center", font="Arial", FontSize=12, optionalCustomization = "", CommandFunc=None, ButtonWidth=100, ButtonHeight=30, BgColor="#f0f0f0", FgColor="#000000", PackType=None, Anchor="center", PadX=0, PadY=0, Side=tk.TOP, Row=0, Column=0, Sticky=None, X=None, Y=None, RelX=None, RelY=None):
+    """
+    # This function creates and returns a custom button that can be also packed within the same function.
+
+    **ForWindow** = This dictates that target where the button will be created for.
+
+    **Button Contents:**
+        Text = What custom text will the button have.
+        Image = What custom image the button will have.
+
+    **Formatting:**
+        Compound = What direction the image will be placed on top of the text.
+            (Options: 'top', 'left', 'center',  'right', 'bottom', 'none')
+        font = What custom font the button will use.
+        FontSize = The size of the font used.
+        OptionalCustomization = Dictates special font formatting such as bold, italic, or underline.
+            (Options: 'bold', 'italic', 'underline', 'overstrike')
+
+    **Extra Customization:**
+        BgColor = What the background of the button will be colored as.
+        FgColor = The color of the text within the button.
+        Anchor = Where the text will be anchored, affects where it will be packed.
+    
+    # Packing Types and their parameters:
+
+    **Pack (The default type, packs label and contains borders.):**
+        PadX = Width for the padding of the label.
+        PadY = Height for the padding of the label.
+        Side = Side where the label will go to in the widget, is relative.
+        Sticky = Position where the label will stick to in the widget, is not relative.
+    
+    **Grid (for mounting grids and organized sheets):**
+        Row = The row where your element will be placed. (Horizontal)
+        Column = the column where your element will be placed. (Vertical)
+        PadX = the padding width your element will have, affects elements in and outside of the grid.
+        PadY = the padding height your element will have, affects elements in and outside of the grid.
+    
+    **Place (for accurately placing elements in absolute or relative positions):**
+        X = The absolute position of the element in your window, cannot be moved. (Width)
+        Y = The absolute position of the element in your window, cannot be moved. (Height)
+        RelX = The relative position of the element in your window, can be moved. (Width)
+        RelY = The relative position of the element in your window, can be moved. (Height)
+    """
+    
+    if not isinstance(ForWindow, (tk.Tk, tk.Frame, tk.Toplevel)):
+        raise TypeError(f"Expected a Tkinter window/frame, but got {type(ForWindow).__name__} instead.")
+
+    TransparentPixel = "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
+    TrasnparentImage = tk.PhotoImage(data=TransparentPixel)
+
+    Compound = Compound.lower()
+
+    if Image is None:
+        newButton = tk.Button(ForWindow, command=CommandFunc, image=TrasnparentImage, text=Text, compound=Compound, font=(font, FontSize, optionalCustomization), width=ButtonWidth, height=ButtonHeight, bg=BgColor, fg=FgColor)
+        newButton.image = TrasnparentImage
+
+    else:
+        newButton = tk.Button(ForWindow, command=CommandFunc, image=Image, text=Text, compound=Compound,  font=(font, FontSize, optionalCustomization), width=ButtonWidth, height=ButtonHeight, bg=BgColor, fg=FgColor)
+        newButton.image = Image
+
+    if PackType is not None:
+        PackType = PackType.lower()
+
+    if PackType is not None and PackType not in ["place", "grid", "pack"]:
+        raise ValueError(f"Expected a proper packing style, but got {PackType} instead. Current packing types are 'Pack', 'Grid', or 'Place'")
+
+    elif PackType == "pack":
+        newButton.pack(anchor=Anchor, padx=PadX, pady=PadY, side=Side, sticky=Sticky)
+    
+    elif PackType == "place":
+        newButton.place(x=X, y=Y, relx=RelX, rely=RelY, anchor=Anchor)
+
+    elif PackType == "grid":
+        newButton.grid(row=Row, column=Column, padx=PadX, pady=PadY)
+    
+    return newButton
+#endregion
+
+#region Creating AplhaNumerical Input Widgets and Miscellaneous
+def CreateMiscInputs(ForWindow, InputType, Border=2, CustomFont="Arial", CustomFontSize=12, CustomFontExtra="", BgColor="#f0f0f0", FgColor="#000000", CommandKeybind=None, CommandFunction=None, SpinboxFrom=-100, SpinboxTo=100, ScaleLength=100, ScaleRepeatDelay=1, ScaleResolution=1, PackType=None, PadX=None, PadY=None, Anchor="center", Side=tk.TOP, Row=0, Column=0, Sticky=None, X=None, Y=None, RelX=None, RelY=None):
+    """
+    # This function can create, pack, and set a command for other, miscellaneous Aplhanumerical input widgets and returns the widget.
+
+    **Essential Parameters:**
+        ForWindow = This parameter dictates what window the custom widget will be created for.
+        InputType = This parameter dictates what custom widget will be created.
+            (Options: Text, Spinbox, Scale)
+
+    **Customization Parameters:** 
+        Border = This parameter defines the border of the created widget.
+        CustomFont = This parameter defines the Font that will be used in the created widget.
+        CustomFontSize = This parameter defines the custom Font Size that the widget will have.
+        CustomFontExtra = This parameter defines any extra properties the font can have, such as Bold.
+            (Options: 'Bold', 'Italic', 'Underline', 'Overstrike'.)
+        BgColor = Defines the background color of the widget.
+        FgColor = Defines the foreground color of the widget.
+
+    **Custom Keybind Parameters:**
+        CommandKeybind = What the custom keybind of said widget will be. Must have CommandFunction to work.
+        CommandFunction = The command that will be executed when pressing the respective keybind. Must have CommandKeybind to work.
+
+    **SpinBox Specific Parameters:**
+        SpinboxFrom = The minimum value that the SpinBox can have.
+        SpinboxTo = The maximum value that the spinbox can have.
+    
+    **Scale Specific Parameters:**
+        ScaleLength = The length of the scale in pixels. (Width, X value.)
+        ScaleRepeatDelay = The frequency that the scale will show numbers based on their position.
+            (For example, a ScaleRepeatDelay of 0.5 would show numbers every 0.5.)
+        ScaleResolution = The rounding that the scale will have upon selecting a value, where it snaps your cursor to said value.
+            (For example, setting to 1 snaps your selector to every integer, skipping decimals. Setting to -1 disables rounding.)
+    
+    # Packing Types and their parameters:
+
+    **Pack (The default type, packs label and contains borders.):**
+        PadX = Width for the padding of the label.
+        PadY = Height for the padding of the label.
+        Side = Side where the label will go to in the widget, is relative.
+        Sticky = Position where the label will stick to in the widget, is not relative.
+    
+    **Grid (for mounting grids and organized sheets):**
+        Row = The row where your element will be placed. (Horizontal)
+        Column = the column where your element will be placed. (Vertical)
+        PadX = the padding width your element will have, affects elements in and outside of the grid.
+        PadY = the padding height your element will have, affects elements in and outside of the grid.
+    
+    **Place (for accurately placing elements in absolute or relative positions):**
+        X = The absolute position of the element in your window, cannot be moved. (Width)
+        Y = The absolute position of the element in your window, cannot be moved. (Height)
+        RelX = The relative position of the element in your window, can be moved. (Width)
+        RelY = The relative position of the element in your window, can be moved. (Height)
+    """
+    
+    if not ForWindow or not InputType:
+        raise ValueError("Could not create miscellaneous input types as one of the necessary values wew not given. Did you try filling the primary essential values?")
+
+    else:
+        InputType = InputType.lower()
+
+        if InputType == "text":
+            NewInput = tk.Text(ForWindow, bg=BgColor, fg=FgColor, bd=Border, font=(CustomFont.capitalize(), CustomFontSize, CustomFontExtra.capitalize()))
+        
+        elif InputType == "spinbox":
+            NewInput = tk.Spinbox(ForWindow, bg=BgColor, fg=FgColor, bd=Border, font=(CustomFont.capitalize(), CustomFontSize, CustomFontExtra.capitalize()), from_=SpinboxFrom, to=SpinboxTo)
+
+        elif InputType == "scale":
+            NewInput = NewInput = tk.Scale(ForWindow, bg=BgColor, fg=FgColor, bd=Border, font=(CustomFont.capitalize(), CustomFontSize, CustomFontExtra.capitalize()), repeatdelay=ScaleRepeatDelay, resolution=ScaleResolution, length=ScaleLength)
+    
+    if CommandKeybind is not None and CommandFunction is not None:
+        def eventNeedlessFunction(event):
+            CommandFunction()
+
+        NewInput.bind(CommandKeybind, eventNeedlessFunction)
+
+    elif CommandKeybind is not None or CommandFunction is not None:
+        raise ValueError("Could not bind a command to this widget as one of the proper 'Command__' were not filled. Did you try checking both the 'Command__' parameters?")
+
+    if PackType is not None:
+        PackType = PackType.lower()
+
+    if PackType is not None and PackType not in ["place", "grid", "pack"]:
+        raise ValueError(f"Expected a proper packing style, but got {PackType} instead. Current packing types are 'Pack', 'Grid', or 'Place'")
+
+    elif PackType == "pack":
+        NewInput.pack(anchor=Anchor, padx=PadX, pady=PadY, side=Side, sticky=Sticky)
+    
+    elif PackType == "place":
+        NewInput.place(x=X, y=Y, relx=RelX, rely=RelY, anchor=Anchor)
+
+    elif PackType == "grid":
+        NewInput.grid(row=Row if Row is not None else 0, column=Column if Column is not None else 0, padx=PadX, pady=PadY)
+
+    return NewInput
+#endregion
+
+#region Creating Boolean Input Widgets and Miscellaneous
+def CreateBoolInputs(ForWindow, WidgetType, Border=2, CustomText="", CustomFont="Arial", CustomFontSize=12, CustomFontExtra="", BgColor="#f0f0f0", FgColor="#000000", CommandKeybind=None, CommandFunction=None, CheckBoxState="NORMAL", CheckBoxOnValue=1, CheckBoxOffValue=0,PackType=None, PadX=None, PadY=None, Anchor="center", Side=tk.TOP, Row=0, Column=0, Sticky=None, X=None, Y=None, RelX=None, RelY=None):
+    """
+    # Creates a miscellaneous input from the Bool type.
+
+    **Essential Parameters:**
+        ForWindow = This parameter dictates what window the custom widget will be created for.
+        WidgetType = This parameter dictates what custom widget will be created.
+            (Options: Text, Spinbox, Scale)
+
+    **Customization Parameters:** 
+        Border = This parameter defines the border of the created widget.
+        CustomFont = This parameter defines the Font that will be used in the created widget.
+        CustomFontSize = This parameter defines the custom Font Size that the widget will have.
+        CustomFontExtra = This parameter defines any extra properties the font can have, such as Bold.
+            (Options: 'Bold', 'Italic', 'Underline', 'Overstrike'.)
+        BgColor = Defines the background color of the widget.
+        FgColor = Defines the foreground color of the widget.
+
+    **Custom Keybind Parameters:**
+        CommandKeybind = What the custom keybind of said widget will be. Must have CommandFunction to work.
+        CommandFunction = The command that will be executed when pressing the respective keybind. Must have CommandKeybind to work.
+    
+    **CheckBox Specific Parameters:**
+        CheckBoxState = 'NORMAL' for the checkbox to function normally. 'DISABLED' for the checkbox to not work.
+        CheckBoxOnValue = The value that the checkbox will return when on.
+        CheckBoxOffValue = The value that the checkbox will return when off.
+
+    # Packing Types and their parameters:
+
+    **Pack (The default type, packs label and contains borders.):**
+        PadX = Width for the padding of the label.
+        PadY = Height for the padding of the label.
+        Side = Side where the label will go to in the widget, is relative.
+        Sticky = Position where the label will stick to in the widget, is not relative.
+    
+    **Grid (for mounting grids and organized sheets):**
+        Row = The row where your element will be placed. (Horizontal)
+        Column = the column where your element will be placed. (Vertical)
+        PadX = the padding width your element will have, affects elements in and outside of the grid.
+        PadY = the padding height your element will have, affects elements in and outside of the grid.
+    
+    **Place (for accurately placing elements in absolute or relative positions):**
+        X = The absolute position of the element in your window, cannot be moved. (Width)
+        Y = The absolute position of the element in your window, cannot be moved. (Height)
+        RelX = The relative position of the element in your window, can be moved. (Width)
+        RelY = The relative position of the element in your window, can be moved. (Height)
+    """
+    
+    if not ForWindow or not WidgetType:
+        raise ValueError("Could not create a bool input widget as the essential parameters were not filled. Did you try checking 'ForWindow' and 'WidgetType'?")
+    
+    else:
+        WidgetType = WidgetType.lower()
+
+        if WidgetType == "checkbutton":
+            NewBool = tk.Checkbutton(ForWindow, bd=Border, text=CustomText, anchor=Anchor, font=(CustomFont.capitalize(), CustomFontSize, CustomFontExtra.capitalize()), bg=BgColor, fg=FgColor, state=CheckBoxState, onvalue=CheckBoxOnValue, offvalue=CheckBoxOffValue)
+
+        elif WidgetType == "radiobutton":
+            NewBool = tk.Radiobutton(ForWindow, bd=Border, anchor=Anchor, text=CustomText, font=(CustomFont.capitalize(), CustomFontSize, CustomFontExtra.capitalize()), bg=BgColor, fg=FgColor)
+
+        elif WidgetType == "listbox":
+            NewBool = tk.Listbox(ForWindow, bd=Border, text=CustomText, font=(CustomFont.capitalize(), CustomFontSize, CustomFontExtra.capitalize()), bg=BgColor, fg=FgColor)
+
+    if CommandKeybind is not None and CommandFunction is not None:
+        def eventNeedlessFunction(event):
+            CommandFunction()
+
+        NewBool.bind(CommandKeybind, eventNeedlessFunction)
+
+    elif CommandKeybind is not None or CommandFunction is not None:
+        raise ValueError("Could not bind a command to this widget as one of the proper 'Command__' were not filled. Did you try checking both the 'Command__' parameters?")
+
+    if PackType is not None:
+        PackType = PackType.lower()
+
+    if PackType is not None and PackType not in ["place", "grid", "pack"]:
+        raise ValueError(f"Expected a proper packing style, but got {PackType} instead. Current packing types are 'Pack', 'Grid', or 'Place'")
+
+    elif PackType == "pack":
+        NewBool.pack(anchor=Anchor, padx=PadX, pady=PadY, side=Side, sticky=Sticky)
+    
+    elif PackType == "place":
+        NewBool.place(x=X, y=Y, relx=RelX, rely=RelY, anchor=Anchor)
+
+    elif PackType == "grid":
+        NewBool.grid(row=Row if Row is not None else 0, column=Column if Column is not None else 0, padx=PadX, pady=PadY)
+
+    return NewBool
+#endregion
+
+#region Better Bind With Additional Improved Features
+def BetterBind(TargetWindow, KeyToBind, FunctionToBind, After=1, RepeatTimes=0, RepeatDelay=1):
+    """
+    # A function that improves Tkinter's .bind() feature, improving it with a new nit-picked quality of life add-ons.
+
+    **Necessary parameters:**
+        TargetWindow = The Tkinter element you want to bind your function and keybind to.
+        FunctionToBind = The function you wish to bind to a key, that runs within the element.
+        KeyToBind = The Keybind you want to set to your element to run your script.
+            (Luckily, here's a couple references!)
+                https://web.archive.org/web/20190512164300id_/http://infohost.nmt.edu/tcc/help/pubs/tkinter/web/event-types.html
+                https://web.archive.org/web/20190515021108id_/http://infohost.nmt.edu/tcc/help/pubs/tkinter/web/key-names.html
+                https://www.tcl-lang.org/man/tcl8.4/TkCmd/keysyms.htm
+
+    **Additional parameters:**
+        After = Dictates the time in **milliseconds** the function will take to run.
+        RepeatTimes = The amount of times the function will repeat after running once.
+            (Note: You can repeat infinitely by typing 'inf' or -1.)
+        RepeatDelay = The delay in **milliseconds** that a function will take to repeat.
+    """
+
+    if TargetWindow and KeyToBind and FunctionToBind:
+        #this is for a single key
+        if len(KeyToBind) == 1:
+            FinalKey = KeyToBind
+
+        #this is for the war veterans whose died plenty for not using <>
+        elif KeyToBind.startswith("<") and KeyToBind.endswith(">"):
+            KeyToBind = KeyToBind.title()
+
+            FinalKey = f"{KeyToBind}"
+
+        #and for the people with dementia
+        else:
+            KeyToBind = KeyToBind.title()
+
+            FinalKey = f"<{KeyToBind}>"
+
+        def EventlessBind(event):
+            def StartFunctions():
+                FunctionRunCount = 0
+
+                def repeatingFunction():
+                    nonlocal FunctionRunCount, RepeatTimes
+                    FunctionToBind()
+
+                    if isinstance(RepeatTimes, str) and RepeatTimes.lower() == "inf":
+                        RepeatTimes = -1
+
+                    elif isinstance(RepeatTimes, str) and RepeatTimes != "inf":
+                        raise TypeError("The function oculd not be repeated as the value typed for RepeatTimes is invalid. Did you try checking the RepeatTimes value type?")
+
+                    FunctionRunCount += 1
+                            
+                    if FunctionRunCount <= RepeatTimes or RepeatTimes == -1:
+                        TargetWindow.after(RepeatDelay, repeatingFunction)
+
+                repeatingFunction()
+
+            TargetWindow.after(After, StartFunctions)
+        
+        TargetWindow.bind(FinalKey, EventlessBind)
+    
+    else:
+        raise ValueError("Could not bind function to an element as one of the necessary parameters were not filled. Have you tried filling all '__ToBind' parameters?")
+#endregion
+
+#region Moving Windows and Changing Their Geometry Smoothly Function
+def BetterGeometry(TargetWindow, SizeX=0, SizeY=0, PosX=None, PosY=None, SizeSmooth=0, PosSmooth=0, Delay=1):
+    """
+    # This function is a better way to set a window's geometry, both in size and position on screen, smoothing included.
+
+    **TargetWindow** = The window in which position or size will be altered.
+
+    **Geometry Positions:**
+        SizeX = The final width that the window will have.
+        SizeY = The final height that the window will have.
+        PosX = The final width position that the window will have.
+        PosY = The final height position that the window will have.
+    
+    **Additional Parameters:**
+        SizeSmooth = How much the change from the current size to the final size will be smoothed. **The lesser the number, the smoother.**
+        PosSmooth = How much the movement from the current position to the final position will be smoothed. **The lesser the number, the smoother.**
+        Delay = The delay in time that will take for the window to go to it's next position. **The lesser the number, the smoother.**
+    """
+
+    TargetWindowX = TargetWindow.winfo_width()
+    TargetWindowY = TargetWindow.winfo_height()
+
+    if SizeSmooth == 0 and PosSmooth == 0:
+        TargetWindow.geometry(f"{SizeX if SizeX != 0 else TargetWindowX}x{SizeY if SizeY != 0 else TargetWindowY}{f'+{PosX}' if PosX is not None else ''}{f'+{PosY}' if PosY is not None else ''}")
+    
+    else:
+        s_smooth = max(1, int(SizeSmooth)) if SizeSmooth and SizeSmooth > 0 else 0
+        p_smooth = max(1, int(PosSmooth)) if PosSmooth and PosSmooth > 0 else 0
+
+        curX, curY = TargetWindow.winfo_x(), TargetWindow.winfo_y()
+        curW, curH = TargetWindow.winfo_width(), TargetWindow.winfo_height()
+
+        tX = int(PosX) if PosX is not None else curX
+        tY = int(PosY) if PosY is not None else curY
+        tW = int(SizeX) if (SizeX is not None and SizeX != 0) else curW
+        tH = int(SizeY) if (SizeY is not None and SizeY != 0) else curH
+
+        def TheTrueSmooth():
+            nonlocal curX, curY, curW, curH
+
+            if p_smooth > 0:
+                if curX != tX:
+                    diffX = tX - curX
+                    if abs(diffX) <= p_smooth: curX = tX
+                    else: curX += p_smooth if diffX > 0 else -p_smooth
+                if curY != tY:
+                    diffY = tY - curY
+                    if abs(diffY) <= p_smooth: curY = tY
+                    else: curY += p_smooth if diffY > 0 else -p_smooth
+
+            if s_smooth > 0:
+                if curW != tW:
+                    diffW = tW - curW
+                    if abs(diffW) <= s_smooth: curW = tW
+                    else: curW += s_smooth if diffW > 0 else -s_smooth
+                if curH != tH:
+                    diffH = tH - curH
+                    if abs(diffH) <= s_smooth: curH = tH
+                    else: curH += s_smooth if diffH > 0 else -s_smooth
+
+            TargetWindow.geometry(f"{curW}x{curH}+{curX}+{curY}")
+
+            if curX != tX or curY != tY or curW != tW or curH != tH:
+                TargetWindow.after(Delay, TheTrueSmooth)
+
+        TheTrueSmooth()        
+#endregion
+
+#endregion
+
+############################################
+# time to move on to tk.Canvas, my nightmare
+############################################
+
+#region ahhh... tk.Canvas, where hell sets loose
+
+#region Function that Automatically Creates and Packs Canvas
+def CreateCanvas(TargetWindow, SizeX=250, SizeY=250, BgColor="#f0f0f0", PackType=None, Anchor="center", PadX=0, PadY=0, Side=tk.TOP, Row=0, Column=0, Sticky=None, X=None, Y=None, RelX=None, RelY=None):
+    """
+    # Creates a tk.Canvas element and automatically packs it.
+
+    **Necessary parameters:**
+        TargetWindow = The window that will be receiving the Canvas.
+
+    **Geometry Parameters:**
+        SizeX = The width in pixels of the Canvas Widget.
+        SizeY = The height in pixels of the Canvas Widget.
+    
+    **Extra Customization:**
+        BgColor = What the background of the label will be colored as.
+
+    # Packing Types and their parameters:
+
+    **Pack (The default type, packs label and contains borders.):**
+        PadX = Width for the padding of the label.
+        PadY = Height for the padding of the label.
+        Side = Side where the label will go to in the widget, is relative.
+        Sticky = Position where the label will stick to in the widget, is not relative.
+    
+    **Grid (for mounting grids and organized sheets):**
+        Row = The row where your element will be placed. (Horizontal)
+        Column = the column where your element will be placed. (Vertical)
+        PadX = the padding width your element will have, affects elements in and outside of the grid.
+        PadY = the padding height your element will have, affects elements in and outside of the grid.
+    
+    **Place (for accurately placing elements in absolute or relative positions):**
+        X = The absolute position of the element in your window, cannot be moved. (Width)
+        Y = The absolute position of the element in your window, cannot be moved. (Height)
+        RelX = The relative position of the element in your window, can be moved. (Width)
+        RelY = The relative position of the element in your window, can be moved. (Height)
+    """
+
+    if not isinstance(TargetWindow, (tk.Tk, tk.Toplevel)):
+        raise TypeError(f"Expected a Tkinter window, but got {type(TargetWindow).__name__} instead.")
+
+    NewCanvas = tk.Canvas(TargetWindow, width=SizeX, height=SizeY, bg=BgColor)
+
+    if PackType is not None:
+        PackType = PackType.lower()
+
+    if PackType is not None and PackType not in ["place", "grid", "pack"]:
+        raise ValueError(f"Expected a proper packing style, but got {PackType} instead. Current packing types are 'Pack', 'Grid', or 'Place'")
+
+    elif PackType == "pack":
+        NewCanvas.pack(anchor=Anchor, padx=PadX, pady=PadY, side=Side, sticky=Sticky)
+    
+    elif PackType == "place":
+        NewCanvas.place(x=X, y=Y, relx=RelX, rely=RelY, anchor=Anchor)
+
+    elif PackType == "grid":
+        NewCanvas.grid(row=Row, column=Column, padx=PadX, pady=PadY)
+
+    return NewCanvas
+#endregion
+
+#region Creating Various Shapes in Canvas
+def CreateCanvasShapes(ForCanvas, Shape, PosX, PosY, SquareSize=25, RectangleX=20, RectangleY=40, CircleSize=25, OvalX=20, OvalY=40, color="blue", OutlineColor="black", ActiveColor=None):
+    """
+    # Creates a custom shape for a tk.Canvas and automatically centers it in the give ncoordinates and size.
+
+    **Necessary parameters:**
+        ForCanvas = Dictates the used tk.Canvas that the shape will be placed in.
+        Shape = What shape will be placed in the tk.Canvas.
+            (Options: Square, Rectangle, Circle, Oval)
+        
+    **Geometry parameters:**
+        PosX = The horizontal position in pixels where the shape will be placed.
+        PosY = The vertical position in pixels where the shape will be placed.
+    
+    **Customization parameters:**
+        Color = The color that the shape will be filled with.
+        OutlineColor = The color of the shape's border.
+        ActiveColor = The color that the shappe will have when it's hovered on, changes back to normal when hovering off.
+
+    # Shape specific parameters
+    
+    **Square parameters:**
+        SquareSize = The size in pixels that the square will have.
+    
+    **Circle parameters:**
+        CircleSize = The size in pixels that the circle will have.
+    
+    **Rectangle parameters:**
+        RectangleX = The width of the rectangle in pixels.
+        RectangleY = The height of the rectangle in pixels.
+    
+    **Oval parameters:**
+        OvalX = The width of the oval in pixels.
+        OvalY = The height of the oval in pixels.
+    """
+
+    if not isinstance(ForCanvas, tk.Canvas):
+        raise ValueError(f"Could not create custom canvas shape as {ForCanvas} is not a valid canvas. Did you try checking the tk.Canvas given?")
+
+    Shape = Shape.lower()
+    color = color.lower()
+    OutlineColor = OutlineColor.lower()
+    ActiveColor = color if ActiveColor is None else ActiveColor.lower()
+
+    if Shape == "square":
+        offset = SquareSize // 2
+        NewShape = ForCanvas.create_rectangle(PosX - offset, PosY - offset, PosX + offset, PosY + offset, fill=color, outline=OutlineColor, activefill=ActiveColor)
+
+    elif Shape == "rectangle":
+        Xoffset = RectangleX // 2
+        Yoffset = RectangleY // 2
+
+        x1 = PosX - Yoffset
+        y1 = PosY - Xoffset
+        x2 = PosX + Yoffset
+        y2 = PosY + Xoffset
+        
+        NewShape = ForCanvas.create_rectangle(x1, y1, x2, y2, fill=color, outline=OutlineColor, activefill=ActiveColor)
+
+    elif Shape == "circle":
+        offset = CircleSize // 2
+        NewShape = ForCanvas.create_oval(PosX - offset, PosY - offset, PosX + offset, PosY + offset, fill=color, outline=OutlineColor, activefill=ActiveColor)
+
+    elif Shape == "oval":
+        Xoffset = OvalX // 2
+        Yoffset = OvalY // 2
+
+        x1 = PosX - Xoffset
+        y1 = PosY - Yoffset
+        x2 = PosX + Yoffset
+        y2 = PosY + Xoffset
+        
+        NewShape = ForCanvas.create_oval(x1, y1, x2, y2, fill=color, outline=OutlineColor, activefill=ActiveColor)
+
+    else:
+        raise ValueError(f"Could not create custom canvas shape as {Shape} is not a valid option. Did you try checking the allowed shapes in the doctype?")
+    
+    return NewShape
+#endregion
+
+#endregion
+
+#############################################
+# time to do some extra stuff that's cool too
+#############################################
+
+#region Messing with Pillow and Image Rendering
+def BetterPhotoImage(Image, RotateDegrees=None, RotateChangeSize=False, ResizeImageX=None, ResizeImageY=None, MirrorImage=None):
+    """
+    # Renders and modifies a custom image using PIL and returns the modified Tkinter ready image.
+
+    **Required parameters:**
+        Image = The file name of the image being used.
+
+    **Image customization parameters:**
+        RotateDegrees = The angle, in degrees, where the image will be rotated. **Must be an integer.**
+        RotateChangeSize = Wether when rotating an image, the size will maintain for be affected. **Does not work without RotateDegrees.**
+        MirrorImage = If the image will be mirrored vertically or horizontally.
+            (Options: 'None', 'Vertical', 'Horizontal')
+
+    **Resizing parameters:**
+        ResizeImageX = Value, in pixels, what the window's width will be resized to.
+        ResizeImageY = Valye, in pixels, what the window's height will be resized to.
+    """
+    #function to tell wether the image is actually valid
+    def is_valid_image_pillow(imgg):
+        try:
+            with img.open(imgg) as immg:
+                immg.verify()
+                return True
+        except (IOError, SyntaxError):
+            return False
+    #liar liar pants on fire i guess
+
+    #back to the actual code
+    if is_valid_image_pillow(Image):
+        NewImage = img.open(Image)
+
+        if NewImage.mode != 'RGBA':
+            NewImage = NewImage.convert('RGBA')
+
+        IMGwidth, IMGheight = NewImage.size
+        
+        if RotateDegrees is not None:
+            if not isinstance(RotateDegrees, bool):
+                warn.warn(f"'RotateChangeSize' value was {RotateChangeSize} and as it is not True or False, was defaulted to false.")
+                RotateChangeSize = False
+            
+            if not isinstance(RotateDegrees, int):
+                raise TypeError("Could not properly rotate image as the value given was not a proper integer. Did you try ")
+
+            NewImage = NewImage.rotate(RotateDegrees, expand=RotateChangeSize, fillcolor=(0, 0, 0, 0))
+            IMGwidth, IMGheight = NewImage.size
+
+        if ResizeImageX is not None or ResizeImageY is not None:
+            NewImage = NewImage.resize((ResizeImageX if ResizeImageX is not None else IMGwidth, ResizeImageY if ResizeImageY is not None else IMGheight))
+
+        if MirrorImage is not None:
+            MirrorImage = MirrorImage.lower()
+
+            if MirrorImage == "vertical":
+                NewImage = NewImage.transpose(Image.FLIP_TOP_BOTTOM)
+            
+            elif MirrorImage == "horizontal":
+                NewImage = NewImage.transpose(Image.FLIP_TOP_BOTTOM)
+            
+            else:
+                raise ValueError("Could not flip image as the given value was not 'vertical' or 'horizontal'. Did you try checking the 'MirrorImage' value?")
+
+        NewImage = imgtk.PhotoImage(NewImage)
+
+        return NewImage
+
+    else:
+        raise ValueError("Could not create a ImageTk image as the file given was not a proper image file/format. Did you try checking the 'Image' parameter given?")
+
+#endregion

easykinter-0.0.1/src/easykinter/__init__.py

@@ -0,0 +1,8 @@
+from .EasyKinter import *
+
+import tkinter
+tk = tkinter
+
+from PIL import Image, ImageTk
+PILimg = Image
+PILimgtk = ImageTk

easykinter-0.0.1/src/easykinter.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: easykinter
+Version: 0.0.1
+Summary: A wrapper to make Tkinter 90% less boring.
+Author-email: Starly <starly.alt.acc1@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pillow>=10.0.0

easykinter-0.0.1/src/easykinter.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/easykinter/EasyKinter.py
+src/easykinter/__init__.py
+src/easykinter.egg-info/PKG-INFO
+src/easykinter.egg-info/SOURCES.txt
+src/easykinter.egg-info/dependency_links.txt
+src/easykinter.egg-info/requires.txt
+src/easykinter.egg-info/top_level.txt

easykinter-0.0.1/src/easykinter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

easykinter-0.0.1/src/easykinter.egg-info/requires.txt

@@ -0,0 +1 @@
+pillow>=10.0.0

easykinter-0.0.1/src/easykinter.egg-info/top_level.txt

@@ -0,0 +1 @@
+easykinter