tkfluent 0.1.1__tar.gz → 0.1.2__tar.gz

{tkfluent-0.1.1 → tkfluent-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tkfluent
-Version: 0.1.1
+Version: 0.1.2
 Summary: Fluent Design for Tkinter
 License: GPL-3.0
 Keywords: tkfluent,tksvg,tkinter,fluent,modern,UI,interface

{tkfluent-0.1.1 → tkfluent-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "tkfluent"
-version = "0.1.1"
+version = "0.1.2"
 description = "Fluent Design for Tkinter"
 authors = ["XiangQinxi <xiangqinxi@outlook.com>"]
 readme = "README.md"

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/__main__.py

@@ -2,7 +2,9 @@ from tkflu import *
 from tkinter import *
 from tkinter.font import *
 
-blue_primary_color()
+orange_primary_color()
+set_animation_steps(10)
+set_animation_step_time(20)
 
 def togglestate():
     if button1.dcget("state") == NORMAL:

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/button.py

@@ -201,12 +201,17 @@ class FluButton(FluButtonCanvas, DDrawWidget, FluToolTipBase, FluGradient):
             else:
                 self._light()
 
-    def _theme(self, mode, style, animate_steps: int = 10):
+    def _theme(self, mode, style, animation_steps: int = None, animation_step_time: int = None):
+        if animation_steps is None:
+            from .designs.animation import get_animation_steps
+            animation_steps = get_animation_steps()
+        if animation_step_time is None:
+            from .designs.animation import get_animation_step_time
+            animation_step_time = get_animation_step_time()
         r = button(mode, style, "rest")
         h = button(mode, style, "hover")
         p = button(mode, style, "pressed")
         d = button(mode, style, "disabled")
-        steps = animate_steps
         if self.dcget("state") == "normal":
             if self.enter:
                 if self.button1:
@@ -217,35 +222,37 @@ class FluButton(FluButtonCanvas, DDrawWidget, FluToolTipBase, FluGradient):
                 now = r
         else:
             now = d
+        #print(animation_step_time)
+        #print(type(animation_step_time))
         if hasattr(self.attributes.rest, "back_color"):
             back_colors = self.generate_hex2hex(
-                self.attributes.rest.back_color, now["back_color"], steps
+                self.attributes.rest.back_color, now["back_color"], animation_steps
             )
             border_colors = self.generate_hex2hex(
-                self.attributes.rest.border_color, now["border_color"], steps
+                self.attributes.rest.border_color, now["border_color"], animation_steps
             )
             if self.attributes.rest.border_color2 is None:
                 self.attributes.rest.border_color2 = self.attributes.rest.border_color
             if now["border_color2"] is None:
                 now["border_color2"] = now["border_color"]
             border_colors2 = self.generate_hex2hex(
-                self.attributes.rest.border_color2, now["border_color2"], steps
+                self.attributes.rest.border_color2, now["border_color2"], animation_steps
             )
             text_colors = self.generate_hex2hex(
-                self.attributes.rest.text_color, now["text_color"], steps
+                self.attributes.rest.text_color, now["text_color"], animation_steps
             )
             import numpy as np
             back_opacitys = np.linspace(
-                float(self.attributes.rest.back_opacity), float(now["back_opacity"]), steps).tolist()
+                float(self.attributes.rest.back_opacity), float(now["back_opacity"]), animation_steps).tolist()
             border_color_opacitys = np.linspace(
-                float(self.attributes.rest.border_color_opacity), float(now["border_color_opacity"]), steps).tolist()
+                float(self.attributes.rest.border_color_opacity), float(now["border_color_opacity"]), animation_steps).tolist()
             if self.attributes.rest.border_color2_opacity is None:
                 self.attributes.rest.border_color2_opacity = self.attributes.rest.border_color_opacity
             if now["border_color2_opacity"] is None:
                 now["border_color2_opacity"] = now["border_color_opacity"]
             border_color2_opacitys = np.linspace(
-                float(self.attributes.rest.border_color2_opacity), float(now["border_color2_opacity"]), steps).tolist()
-            for i in range(steps):
+                float(self.attributes.rest.border_color2_opacity), float(now["border_color2_opacity"]), animation_steps).tolist()
+            for i in range(animation_steps):
                 def update(ii=i):
                     from easydict import EasyDict
                     tempcolor = EasyDict(
@@ -263,8 +270,8 @@ class FluButton(FluButtonCanvas, DDrawWidget, FluToolTipBase, FluGradient):
                     )
                     self._draw(None, tempcolor)
 
-                self.after(i * 10, update)
-            self.after(steps * 10 + 10, lambda: self._draw(None, None))
+                self.after(i * animation_step_time, update)
+            #self.after(animation_steps * animation_step_time + 10, lambda: self._draw(None, None))
 
         self.dconfigure(
             rest={

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/bwm.py

@@ -126,20 +126,25 @@ class BWm(FluGradient):
         else:
             self._light()
 
-    def _theme(self, mode):
+    def _theme(self, mode, animation_steps: int = None, animation_step_time: int = None):
         from .designs.window import window
         n = window(mode)
         """if self.attributes.back_color is not None:
             n["back_color"] = self.attributes.back_color"""
-
+        if animation_steps is None:
+            from .designs.animation import get_animation_steps
+            animation_steps = get_animation_steps()
+        if animation_step_time is None:
+            from .designs.animation import get_animation_step_time
+            animation_step_time = get_animation_step_time()
         if self.dcget("back_color"):
-            back_colors = self.generate_hex2hex(self.dcget("back_color"), n["back_color"], steps=10)
-            for i in range(10):
+            back_colors = self.generate_hex2hex(self.dcget("back_color"), n["back_color"], steps=animation_steps)
+            for i in range(animation_steps):
                 def update(ii=i):  # 使用默认参数立即捕获i的值
                     self.dconfigure(back_color=back_colors[ii])
                     self._draw()
 
-                self.after(i * 10, update)  # 直接传递函数，不需要lambda
+                self.after(i * animation_step_time, update)  # 直接传递函数，不需要lambda
 
         self.dconfigure(
             back_color=n["back_color"],

tkfluent-0.1.2/tkflu/demos/designer.py

@@ -0,0 +1,33 @@
+from tkflu import *
+
+set_animation_steps(10)
+set_animation_step_time(10)
+
+root = FluWindow()
+root.title("tkfluent designer")
+root.geometry("500x300")
+
+theme_manager = FluThemeManager(root)
+
+menubar = FluMenuBar(root)
+
+menu1 = FluMenu()
+menu1.geometry("90x90")
+menu1.add_command(label="Light", command=lambda: theme_manager.mode("light"))
+menu1.add_command(label="Dark", command=lambda: theme_manager.mode("dark"))
+
+def func1():
+    messagebox = FluToplevel()
+    messagebox.geometry("300x200")
+
+    label = FluLabel(messagebox, text="This is a example for tkfluent!", width=160, height=32)
+    label.pack(anchor="center")
+
+menubar.add_command(label="File", style="standard", width=40, command=lambda: print("File -> Clicked"))
+menubar.add_cascade(label="Theme Mode", style="standard", width=100, menu=menu1)
+menubar.add_command(label="About", style="standard", width=40, command=lambda: func1())
+
+menubar.show()
+
+
+root.mainloop()

tkfluent-0.1.2/tkflu/demos/grad2.py

@@ -0,0 +1,17 @@
+from tkflu import *
+
+set_animation_steps(20)
+set_animation_step_time(50)
+
+root = FluWindow()
+
+theme_manager = FluThemeManager(root)
+
+frame = FluFrame(root, mode="light", style="standard")
+
+btn = FluButton(frame, text="Button", mode="light", style="standard", command=lambda: theme_manager.toggle())
+btn.pack(padx=20, pady=20, fill="both", expand="yes")
+
+frame.pack(padx=20, pady=20, fill="both", expand="yes")
+
+root.mainloop()

tkfluent-0.1.2/tkflu/demos/grad3.py

@@ -0,0 +1,16 @@
+from tkflu import *
+
+set_animation_steps(20)
+set_animation_step_time(20)
+
+root = FluWindow()
+
+theme_manager = FluThemeManager(root)
+
+button = FluButton(root, text="Button", mode="light", style="standard", command=lambda: theme_manager.toggle())
+button.pack(padx=20, pady=20, fill="both", expand="yes")
+
+label = FluLabel(root, text="Label", mode="light")
+label.pack(padx=20, pady=20, fill="both", expand="yes")
+
+root.mainloop()

tkfluent-0.1.2/tkflu/designs/__init__.py

@@ -0,0 +1,3 @@
+from .design import FluDesign
+from .primary_color import FluPrimaryColor, set_primary_color, get_primary_color
+from .animation import FluAnimation, set_animation_steps, set_animation_step_time, get_animation_steps, get_animation_step_time

tkfluent-0.1.2/tkflu/designs/animation.py

@@ -0,0 +1,37 @@
+from os import environ
+
+
+def set_animation_steps(steps: int):
+    environ["tkfluent.animation_steps"] = str(steps)
+
+def get_animation_steps():
+    return int(environ["tkfluent.animation_steps"])
+
+def set_animation_step_time(step_time: int):
+    environ["tkfluent.animation_step_time"] = str(step_time)
+
+def get_animation_step_time():
+    return int(environ["tkfluent.animation_step_time"])
+
+if "tkfluent.animation_steps" not in environ:
+    set_animation_steps(10)
+if "tkfluent.animation_step_time" not in environ:
+    set_animation_step_time(10)
+
+
+class FluAnimation(object):
+    def animation_steps(self, steps: int = None):
+        if steps:
+            from os import environ
+            environ["tkfluent.animation_steps"] = str(steps)
+        else:
+            from os import environ
+            return int(environ["tkfluent.animation_steps"])
+
+    def animation_step_time(self, step_time: int = None):
+        if step_time:
+            from os import environ
+            environ["tkfluent.animation_step_time"] = str(step_time)
+        else:
+            from os import environ
+            return int(environ["tkfluent.animation_step_time"])

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/designs/gradient.py

@@ -34,6 +34,8 @@ class FluGradient:
         rgb_end = self.hex_to_rgb(end_hex)
         import numpy as np
         gradient = []
+        if steps is None:
+            return None
         for t in np.linspace(0, 1, steps):
             # 计算每个通道的中间值
             r = int(rgb_start[0] + (rgb_end[0] - rgb_start[0]) * t)

tkfluent-0.1.2/tkflu/designs/label.py

@@ -0,0 +1,10 @@
+def label(mode: str):
+    mode = mode.lower()
+    if mode == "light":
+        return {
+            "text_color": "#000000",
+        }
+    else:
+        return {
+            "text_color": "#ffffff",
+        }

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/designs/menubar.py

@@ -1,6 +1,3 @@
-from .primary_color import get_primary_color
-
-
 def menubar(mode):
     mode = mode.lower()
     if mode == "light":

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/designs/primary_color.py

@@ -1,16 +1,16 @@
+from os import environ
+
+
 def set_primary_color(color: tuple = None):
-    from os import environ
     from json import dumps
     environ["tkfluent.primary_color"] = dumps(color)
 
-
 def get_primary_color():
-    from os import environ
     from json import loads
     return loads(environ["tkfluent.primary_color"])
 
-
-set_primary_color(("#005fb8", "#60cdff"))
+if "tkfluent.primary_color" not in environ:
+    set_primary_color(("#005fb8", "#60cdff"))
 
 
 class FluPrimaryColor(object):

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/frame.py

@@ -180,16 +180,26 @@ class FluFrame(Frame, DObject, FluGradient):
             else:
                 self._light()
 
-    def _theme(self, mode, style, animate_steps: int = 10):
+    def _theme(self, mode, style, animation_steps: int = None, animation_step_time: int = None):
         n = frame(mode, style)
+
+        if animation_steps is None:
+            from .designs.animation import get_animation_steps
+            animation_steps = get_animation_steps()
+        if animation_step_time is None:
+            from .designs.animation import get_animation_step_time
+            animation_step_time = get_animation_step_time()
+
         if hasattr(self.attributes, "back_color") and hasattr(n, "back_color"):
-            back_colors = self.generate_hex2hex(self.attributes.back_color, n["back_color"], steps=10)
-            for i in range(10):
+            back_colors = self.generate_hex2hex(self.attributes.back_color, n["back_color"], steps=animation_steps)
+            for i in range(animation_steps):
                 def update(ii=i):  # 使用默认参数立即捕获i的值
+                    print(back_colors[ii])
                     self._draw(tempcolor=back_colors[ii])
+                    self.update()
 
-                self.after(i * 10, update)  # 直接传递函数，不需要lambda
-        self.after(animate_steps * 10 + 50, lambda: self.update())
+                self.after(i * animation_step_time, update)  # 直接传递函数，不需要lambda
+        self.after(animation_steps * animation_step_time + 10, lambda: self._draw())
         self.dconfigure(
             back_color=n["back_color"],
             border_color=n["border_color"],
@@ -310,5 +320,10 @@ class FluFrame(Frame, DObject, FluGradient):
             height=self.canvas.winfo_height() - _border_width * 2 - _radius
         )
 
+        self.update()
+
+        self.after(100, lambda: self.update())
+        self.after(100, lambda: self.config(background=_back_color))
+
     def _event_configure(self, event=None):
         self._draw(event)

tkfluent-0.1.2/tkflu/label.py

@@ -0,0 +1,78 @@
+from tkdeft.windows.drawwidget import DDrawWidget
+from .tooltip import FluToolTipBase
+from .designs.gradient import FluGradient
+
+
+class FluLabel(DDrawWidget, FluToolTipBase, FluGradient):
+    def __init__(self, *args,
+                 text="",
+                 width=120,
+                 height=32,
+                 font=None,
+                 mode="light",
+                 **kwargs):
+        self._init(mode)
+
+        super().__init__(*args, width=width, height=height, **kwargs)
+
+        self.dconfigure(
+            text=text,
+        )
+
+        from .defs import set_default_font
+        set_default_font(font, self.attributes)
+
+    def _init(self, mode):
+
+        from easydict import EasyDict
+
+        self.attributes = EasyDict(
+            {
+                "text": "",
+                "command": None,
+                "font": None,
+
+                "text_color": "#1b1b1b",
+            }
+        )
+
+        self.theme(mode=mode)
+
+    def _draw(self, event=None, tempcolor=None):
+        super()._draw(event)
+
+        self.delete("all")
+
+        if tempcolor:
+            _text_color = tempcolor
+        else:
+            _text_color = self.attributes.text_color
+
+        self.element_text = self.create_text(
+            self.winfo_width() / 2, self.winfo_height() / 2, anchor="center",
+            fill=_text_color, text=self.attributes.text, font=self.attributes.font
+        )
+
+    def theme(self, mode="light", animation_steps: int = None, animation_step_time: int = None):
+        from .designs.label import label
+        self.mode = mode
+        m = label(mode)
+
+        if animation_steps is None:
+            from .designs.animation import get_animation_steps
+            animation_steps = get_animation_steps()
+        if animation_step_time is None:
+            from .designs.animation import get_animation_step_time
+            animation_step_time = get_animation_step_time()
+
+        if hasattr(self, "tk"):
+            if self.attributes.text_color != m["text_color"]:
+                text_colors = self.generate_hex2hex(self.attributes.text_color, m["text_color"], steps=animation_steps)
+                for i in range(animation_steps):
+                    def update(ii=i):  # 使用默认参数立即捕获i的值
+                        self._draw(tempcolor=text_colors[ii])
+
+                    self.after(i * animation_step_time, update)  # 直接传递函数，不需要lambda
+        self.dconfigure(
+            text_color=m["text_color"]
+        )

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/menu.py

@@ -88,7 +88,7 @@ class FluMenu(FluPopupMenu, FluToolTipBase):
         def command(event=None):
             #print(menu._w)
 
-            menu.popup(widget.winfo_rootx()+widget.winfo_width()+100, widget.winfo_rooty())
+            menu.popup(widget.winfo_rootx()+widget.winfo_width()+self.winfo_width(), widget.winfo_rooty())
             menu.window.deiconify()
             menu.window.attributes("-topmost")
 

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/menubar.py

@@ -130,30 +130,35 @@ class FluMenuBar(Frame, DObject, FluGradient):
                     widget._draw()
                 widget.update()
 
-    def theme_myself(self, mode="light", animate_steps: int = 10):
+    def theme_myself(self, mode="light", animation_steps: int = None, animation_step_time: int = None):
+        if animation_steps is None:
+            from .designs.animation import get_animation_steps
+            animation_steps = get_animation_steps()
+        if animation_step_time is None:
+            from .designs.animation import get_animation_step_time
+            animation_step_time = get_animation_step_time()
         from .designs.menubar import menubar
         m = menubar(mode)
         self.mode = mode
-        if mode.lower() == "dark":
-            if hasattr(self, "tk"):
-                back_colors = self.generate_hex2hex(self.attributes.back_color, m["back_color"], steps=10)
-                for i in range(10):
+        if hasattr(self, "tk"):
+            if mode.lower() == "dark":
+                back_colors = self.generate_hex2hex(self.attributes.back_color, m["back_color"], steps=animation_steps)
+                for i in range(animation_steps):
                     def update(ii=i):  # 使用默认参数立即捕获i的值
                         self.dconfigure(back_color=back_colors[ii])
                         self._draw()
 
-                    self.after(i * 10, update)  # 直接传递函数，不需要lambda
-                self.after(animate_steps*10+50, lambda: self.update_children())
-        else:
-            if hasattr(self, "tk"):
-                back_colors = self.generate_hex2hex(self.attributes.back_color, m["back_color"], steps=10)
-                for i in range(10):
+                    self.after(i * animation_step_time, update)  # 直接传递函数，不需要lambda
+            else:
+                back_colors = self.generate_hex2hex(self.attributes.back_color, m["back_color"], steps=animation_steps)
+                for i in range(animation_steps):
                     def update(ii=i):  # 使用默认参数立即捕获i的值
                         self.dconfigure(back_color=back_colors[ii])
                         self._draw()
 
-                    self.after(i * 20, update)  # 直接传递函数，不需要lambda
+                    self.after(i * animation_step_time, update)  # 直接传递函数，不需要lambda
 
+            self.after(animation_steps * animation_step_time + 50, lambda: self.update_children())
 
     def _draw(self, event=None):
         self.config(background=self.attributes.back_color)

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/thememanager.py

@@ -13,7 +13,7 @@ class FluThemeManager(object):
         self.mode(self._mode)
         self._window.after(delay, lambda: self.mode(self._mode))
 
-    def mode(self, mode: str, delay: int or None = 0):
+    def mode(self, mode: str, delay: int or None = 50):
         def _():
             self._mode = mode
             if hasattr(self._window, "theme"):
@@ -40,27 +40,12 @@ class FluThemeManager(object):
                 if hasattr(widget, "update_children"):
                     widget.update_children()
                 widget.update()
-        #self._window.after(delay+300, __)
+        #print(len(self._window.winfo_children()))
+        self._window.after(delay+len(self._window.winfo_children()), __)
 
     def toggle(self, delay: int or None = None):
         if self._mode == "light":
             mode = "dark"
         else:
             mode = "light"
-        def _():
-            self._mode = mode
-            if hasattr(self._window, "theme"):
-                self._window.theme(mode=mode)
-                if hasattr(self._window, "_draw"):
-                    self._window._draw()
-                self._window.update()
-            for widget in self._window.winfo_children():
-                if hasattr(widget, "theme"):
-                    widget.theme(mode=mode)
-                    if hasattr(widget, "_draw"):
-                        widget._draw()
-                    widget.update()
-        if delay:
-            self._window.after(delay, _)
-        else:
-            _()
+        self.mode(mode)

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/togglebutton.py

@@ -391,21 +391,14 @@ class FluToggleButton(FluToggleButtonCanvas, DDrawWidget, FluToolTipBase, FluGra
     def invoke(self):
         self.attributes.command()
 
-    def toggle(self, animate_steps: int = 10):
-        """
-
-        "back_color": "#ffffff",
-        "back_opacity": "0.7",
-        "border_color": "#000000",
-        "border_color_opacity": "0.2",
-        "border_color2": "#000000",
-        "border_color2_opacity": "0.3",
-        "border_width": 1,
-        "radius": 6,
-        "text_color": "#000000",
-        :return:
-        """
-        steps = animate_steps
+    def toggle(self, animation_steps: int = None, animation_step_time: int = None):
+        if animation_steps is None:
+            from .designs.animation import get_animation_steps
+            animation_steps = get_animation_steps()
+        if animation_step_time is None:
+            from .designs.animation import get_animation_step_time
+            animation_step_time = get_animation_step_time()
+        steps = animation_steps
         check = self.attributes.check
         uncheck = self.attributes.uncheck
         if uncheck.pressed.border_color2 is None:
@@ -476,5 +469,5 @@ class FluToggleButton(FluToggleButtonCanvas, DDrawWidget, FluToolTipBase, FluGra
                     }
                 )
                 self._draw(None, tempcolor)
-            self.after(i*10, update)
-        self.after(steps*10+10, lambda: self._draw(None, None))
+            self.after(i*animation_step_time, update)
+        self.after(steps*animation_step_time+10, lambda: self._draw(None, None))

{tkfluent-0.1.1 → tkfluent-0.1.2}/tkflu/toplevel.py

@@ -18,12 +18,28 @@ class FluToplevel(Toplevel, BWm, DObject):
         :param kwargs: 参照tkinter.TK.__init__
         """
 
+        Toplevel.__init__(self, *args, **kwargs)
+
         self._init(mode)
 
         self.custom = False
 
-        Toplevel.__init__(self, *args, **kwargs)
+        # 设置窗口图标
+        from .icons import light
+        from tkinter import PhotoImage
+        self.iconphoto(False, PhotoImage(file=light()))
 
         self.bind("<Configure>", self._event_configure, add="+")
         self.bind("<Escape>", self._event_key_esc, add="+")
         self.protocol("WM_DELETE_WINDOW", self._event_delete_window)
+
+    def theme(self, mode: str):
+        super().theme(mode)
+        self._mode = mode
+        for widget in self.winfo_children():
+            if hasattr(widget, "theme"):
+                widget.theme(mode=mode)
+                if hasattr(widget, "_draw"):
+                    widget._draw()
+                if hasattr(widget, "update_children"):
+                    widget.update_children()

tkfluent-0.1.1/tkflu/demos/grad2.py

@@ -1,140 +0,0 @@
-import tkinter as tk
-from tkinter import ttk
-import numpy as np
-
-
-class GradientLabelApp:
-    def __init__(self, root):
-        self.root = root
-        self.root.title("Tkinter渐变标签演示")
-        self.root.geometry("400x200")
-
-        # 渐变控制变量
-        self.is_animating = False
-        self.current_step = 0
-        self.gradient_steps = 20  # 渐变步数
-
-        # 创建UI组件
-        self.create_widgets()
-
-        # 预生成渐变序列 (从蓝色到红色)
-        self.gradient = self.generate_gradient_hex(
-            "#ffffff",
-            "#005fb8",
-            self.gradient_steps
-        )
-
-    def create_widgets(self):
-        """创建界面组件"""
-        # 渐变显示标签
-        self.label = tk.Label(
-            self.root,
-            text="渐变背景标签",
-            font=('Arial', 20),
-            relief='raised',
-            borderwidth=2
-        )
-        self.label.pack(pady=20, ipadx=50, ipady=30, fill='x', padx=20)
-
-        # 控制按钮框架
-        button_frame = ttk.Frame(self.root)
-        button_frame.pack(pady=10)
-
-        # 开始按钮
-        self.start_button = ttk.Button(
-            button_frame,
-            text="开始渐变",
-            command=self.toggle_animation
-        )
-        self.start_button.pack(side='left', padx=5)
-
-        # 重置按钮
-        ttk.Button(
-            button_frame,
-            text="重置",
-            command=self.reset_animation
-        ).pack(side='left', padx=5)
-
-    def generate_gradient(self, start_color, end_color, steps):
-        """生成颜色渐变序列"""
-        gradient = []
-        for t in np.linspace(0, 1, steps):
-            r = int(start_color[0] + (end_color[0] - start_color[0]) * t)
-            g = int(start_color[1] + (end_color[1] - start_color[1]) * t)
-            b = int(start_color[2] + (end_color[2] - start_color[2]) * t)
-            gradient.append(f"#{r:02x}{g:02x}{b:02x}")
-        return gradient
-
-    def generate_gradient_hex(self, start_hex, end_hex, steps):
-        """
-        专为HEX颜色设计的渐变生成器
-        :param start_hex: 起始颜色 HEX格式 (如 "#FF0000")
-        :param end_hex: 结束颜色 HEX格式 (如 "#0000FF")
-        :param steps: 渐变步数
-        :return: HEX格式的颜色列表
-        """
-
-        # 去除#号并转换为RGB元组
-        def hex_to_rgb(h):
-            h = h.lstrip('#')
-            return tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))
-
-        # RGB转HEX
-        def rgb_to_hex(rgb):
-            return f"#{rgb[0]:02x}{rgb[1]:02x}{rgb[2]:02x}"
-
-        rgb_start = hex_to_rgb(start_hex)
-        rgb_end = hex_to_rgb(end_hex)
-
-        gradient = []
-        for t in np.linspace(0, 1, steps):
-            # 计算每个通道的中间值
-            r = int(rgb_start[0] + (rgb_end[0] - rgb_start[0]) * t)
-            g = int(rgb_start[1] + (rgb_end[1] - rgb_start[1]) * t)
-            b = int(rgb_start[2] + (rgb_end[2] - rgb_start[2]) * t)
-
-            # 确保值在0-255范围内并转换为HEX
-            gradient.append(rgb_to_hex((
-                max(0, min(255, r)),
-                max(0, min(255, g)),
-                max(0, min(255, b))
-            )))
-
-        return gradient
-
-    def toggle_animation(self):
-        """切换动画状态"""
-        self.is_animating = not self.is_animating
-        self.start_button.config(
-            text="停止渐变" if self.is_animating else "开始渐变"
-        )
-        if self.is_animating:
-            self.animate_gradient()
-
-    def animate_gradient(self):
-        """执行渐变动画"""
-        if not self.is_animating:
-            return
-
-        # 更新标签背景色
-        color = self.gradient[self.current_step]
-        self.label.config(background=color)
-
-        # 更新步进
-        self.current_step = (self.current_step + 1) % len(self.gradient)
-
-        # 50ms后继续下一帧 (约20FPS)
-        self.root.after(50, self.animate_gradient)
-
-    def reset_animation(self):
-        """重置动画状态"""
-        self.is_animating = False
-        self.current_step = 0
-        self.start_button.config(text="开始渐变")
-        self.label.config(background='SystemButtonFace')  # 恢复默认背景色
-
-
-if __name__ == "__main__":
-    root = tk.Tk()
-    app = GradientLabelApp(root)
-    root.mainloop()

tkfluent-0.1.1/tkflu/demos/grad3.py

@@ -1,11 +0,0 @@
-from tkflu import *
-
-
-root = FluWindow()
-
-theme_manager = FluThemeManager(root)
-
-btn = FluButton(root, text="Button", mode="light", style="standard", command=lambda: theme_manager.toggle())
-btn.pack()
-
-root.mainloop()

tkfluent-0.1.1/tkflu/designs/__init__.py

@@ -1,2 +0,0 @@
-from .design import FluDesign
-from .primary_color import FluPrimaryColor, set_primary_color, get_primary_color

tkfluent-0.1.1/tkflu/label.py

@@ -1,65 +0,0 @@
-from tkdeft.windows.drawwidget import DDrawWidget
-from .tooltip import FluToolTipBase
-
-
-class FluLabel(DDrawWidget, FluToolTipBase):
-    def __init__(self, *args,
-                 text="",
-                 width=120,
-                 height=32,
-                 font=None,
-                 mode="light",
-                 **kwargs):
-        self._init(mode)
-
-        super().__init__(*args, width=width, height=height, **kwargs)
-
-        self.dconfigure(
-            text=text,
-        )
-
-        from .defs import set_default_font
-        set_default_font(font, self.attributes)
-
-    def _init(self, mode):
-
-        from easydict import EasyDict
-
-        self.attributes = EasyDict(
-            {
-                "text": "",
-                "command": None,
-                "font": None,
-
-                "text_color": "#1b1b1b",
-            }
-        )
-
-        self.theme(mode=mode)
-
-    def _draw(self, event=None):
-        super()._draw(event)
-
-        self.delete("all")
-
-        self.element_text = self.create_text(
-            self.winfo_width() / 2, self.winfo_height() / 2, anchor="center",
-            fill=self.attributes.text_color, text=self.attributes.text, font=self.attributes.font
-        )
-
-    def theme(self, mode="light"):
-        self.mode = mode
-        if mode.lower() == "dark":
-            self._dark()
-        else:
-            self._light()
-
-    def _light(self):
-        self.dconfigure(
-            text_color="#000000"
-        )
-
-    def _dark(self):
-        self.dconfigure(
-            text_color="#ffffff"
-        )