tkfluent 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

tkflu/designs/__init__.py

@@ -1,2 +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

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"])

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)

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",
+        }

tkflu/designs/menubar.py

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

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):

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 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):
-                def update(ii=i):  # 使用默认参数立即捕获i的值
-                    self._draw(tempcolor=back_colors[ii])
-
-                self.after(i * 10, update)  # 直接传递函数，不需要lambda
-        self.after(animate_steps * 10 + 50, lambda: self.update())
+
+        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 not animation_steps == 0 or not animation_step_time == 0:
+            if hasattr(self.attributes, "back_color") and hasattr(n, "back_color"):
+                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 * 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)

tkflu/image.py

@@ -0,0 +1,4 @@
+from .frame import FluFrame
+
+
+class FluImage(FluFrame):

tkflu/label.py

@@ -1,8 +1,9 @@
 from tkdeft.windows.drawwidget import DDrawWidget
 from .tooltip import FluToolTipBase
+from .designs.gradient import FluGradient
 
 
-class FluLabel(DDrawWidget, FluToolTipBase):
+class FluLabel(DDrawWidget, FluToolTipBase, FluGradient):
     def __init__(self, *args,
                  text="",
                  width=120,
@@ -37,29 +38,43 @@ class FluLabel(DDrawWidget, FluToolTipBase):
 
         self.theme(mode=mode)
 
-    def _draw(self, event=None):
+    def _draw(self, event=None, tempcolor=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
-        )
+        if tempcolor:
+            _text_color = tempcolor
+        else:
+            _text_color = self.attributes.text_color
 
-    def theme(self, mode="light"):
-        self.mode = mode
-        if mode.lower() == "dark":
-            self._dark()
+        if not hasattr(self, "element_text"):
+            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
+            )
         else:
-            self._light()
+            self.coords(self.element_text, self.winfo_width() / 2, self.winfo_height() / 2)
+            self.itemconfigure(self.element_text, fill=_text_color, text=self.attributes.text, font=self.attributes.font)
 
-    def _light(self):
+    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="#000000"
+            text_color=m["text_color"]
         )
-
-    def _dark(self):
-        self.dconfigure(
-            text_color="#ffffff"
-        )

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")
 

tkflu/menubar.py

@@ -130,30 +130,42 @@ 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):
-                    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):
-                    def update(ii=i):  # 使用默认参数立即捕获i的值
-                        self.dconfigure(back_color=back_colors[ii])
-                        self._draw()
-
-                    self.after(i * 20, update)  # 直接传递函数，不需要lambda
-
+        if hasattr(self, "tk"):
+            if not animation_steps == 0 or not animation_step_time == 0:
+                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 * 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 * animation_step_time, update)  # 直接传递函数，不需要lambda
+
+                self.after(animation_steps * animation_step_time + 50, lambda: self.update_children())
+            else:
+                if mode.lower() == "dark":
+                    self.dconfigure(back_color=m["back_color"])
+                else:
+                    self.dconfigure(back_color=m["back_color"])
+                self._draw()
 
     def _draw(self, event=None):
         self.config(background=self.attributes.back_color)

tkflu/text.py

@@ -172,6 +172,8 @@ class FluText(FluTextCanvas, DDrawWidget, FluToolTipBase):
             height=self.winfo_height() - _border_width * 2 - _radius
         )
 
+        if hasattr(self, "element_border"):
+            self.delete(self.element_border)
         self.element_border = self.create_round_rectangle(
             0, 0, width, height, _radius, temppath=self.temppath,
             fill=_back_color, fill_opacity=_back_opacity, stop1=_stop1, stop2=_stop2,
@@ -179,20 +181,50 @@ class FluText(FluTextCanvas, DDrawWidget, FluToolTipBase):
             outline2_opacity=_border_color2_opacity,
             width=_border_width
         )
-
+        """if _underline_fill:
+            if not hasattr(self, "element_line"):
+                self.element_line = self.create_line(
+                    _radius / 3 + _border_width, self.winfo_height() - _radius / 3,
+                    self.winfo_width() - _radius / 3 - _border_width * 2, self.winfo_height() - _radius / 3,
+                    width=_underline_width, fill=_underline_fill
+                )
+            else:
+                self.coords(
+                    self.element_line, _radius / 3 + _border_width, self.winfo_height() - _radius / 3,
+                    self.winfo_width() - _radius / 3 - _border_width * 2, self.winfo_height() - _radius / 3,
+                )
+                self.itemconfigure(self.element_line, width=_underline_width, fill=_underline_fill)
+        """
+        if hasattr(self, "element_line"):
+            self.delete(self.element_line)
         if _underline_fill:
             self.element_line = self.create_line(
                 _radius / 3 + _border_width, self.winfo_height() - _radius / 3,
                 self.winfo_width() - _radius / 3 - _border_width * 2, self.winfo_height() - _radius / 3,
                 width=_underline_width, fill=_underline_fill
             )
-
+        """        
+        if not hasattr(self, "element_text"):
+            self.element_text = self.create_window(
+                self.winfo_width() / 2, self.winfo_height() / 2,
+                window=self.text,
+                width=self.winfo_width() - _border_width * 2 - _radius,
+                height=self.winfo_height() - _border_width * 2 - _radius
+            )
+        else:
+            self.coords(self.element_text, self.winfo_width() / 2, self.winfo_height() / 2,
+                        self.winfo_width() - _border_width * 2 - _radius, self.winfo_height() - _border_width * 2 - _radius)
+        """
+        if hasattr(self, "element_text"):
+            self.delete(self.element_text)
         self.element_text = self.create_window(
             self.winfo_width() / 2, self.winfo_height() / 2,
             window=self.text,
             width=self.winfo_width() - _border_width * 2 - _radius,
             height=self.winfo_height() - _border_width * 2 - _radius
         )
+        self.tag_raise(self.element_text, self.element_border)
+        self.tag_raise(self.element_line, self.element_border)
 
         #self.tag_raise(self.element_text)
 

tkflu/thememanager.py

@@ -1,9 +1,10 @@
 from .window import FluWindow
 from .toplevel import FluToplevel
+from typing import Union
 
 
 class FluThemeManager(object):
-    def __init__(self, window=None, mode: str = "light", delay: int or None = 100):
+    def __init__(self, window=None, mode: str = "light", delay: Union[int, None] = 100):
         if window:
             self._window = window
         else:
@@ -13,7 +14,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: Union[int, None] = 50):
         def _():
             self._mode = mode
             if hasattr(self._window, "theme"):
@@ -40,27 +41,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):
+    def toggle(self, delay: Union[int, 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)

tkflu/togglebutton.py

@@ -391,90 +391,89 @@ 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()
         check = self.attributes.check
         uncheck = self.attributes.uncheck
-        if uncheck.pressed.border_color2 is None:
-            uncheck.pressed.border_color2 = uncheck.pressed.border_color
-        if check.pressed.border_color2  is None:
-            check.pressed.border_color2 = check.pressed.border_color
-        if uncheck.pressed.border_color2_opacity is None:
-            uncheck.pressed.border_color2_opacity = uncheck.pressed.border_color_opacity
-        if check.pressed.border_color2_opacity is None:
-            check.pressed.border_color2_opacity = check.pressed.border_color_opacity
-        if self.attributes.checked:
-            self.attributes.checked = False
-            back_colors = self.generate_hex2hex(
-                check.pressed.back_color, uncheck.rest.back_color, steps
-            )
-            border_colors = self.generate_hex2hex(
-                check.pressed.border_color, uncheck.rest.border_color, steps
-            )
-            border_colors2 = self.generate_hex2hex(
-                check.pressed.border_color2, uncheck.rest.border_color2, steps
-            )
-            text_colors = self.generate_hex2hex(
-                check.pressed.text_color, uncheck.rest.text_color, steps
-            )
-            import numpy as np
-            back_opacitys = np.linspace(
-                float(check.pressed.back_opacity), float(uncheck.rest.back_opacity), steps).tolist()
-            border_color_opacitys = np.linspace(
-                float(check.pressed.border_color_opacity), float(uncheck.rest.border_color_opacity), steps).tolist()
-            border_color2_opacitys = np.linspace(
-                float(check.pressed.border_color2_opacity), float(uncheck.rest.border_color2_opacity), steps).tolist()
-        else:
-            self.attributes.checked = True
-            back_colors = self.generate_hex2hex(
-                uncheck.pressed.back_color, check.rest.back_color, steps
-            )
-            border_colors = self.generate_hex2hex(
-                uncheck.pressed.back_color, check.rest.back_color, steps
-            )
-            border_colors2 = self.generate_hex2hex(
-                uncheck.pressed.border_color2, check.rest.border_color2, steps
-            )
-            text_colors = self.generate_hex2hex(
-                uncheck.pressed.text_color, check.rest.text_color, steps
-            )
-            import numpy as np
-            back_opacitys = np.linspace(float(uncheck.pressed.back_opacity), float(check.rest.back_opacity),
-                                        steps).tolist()
-            border_color_opacitys = np.linspace(float(uncheck.pressed.border_color_opacity), float(check.rest.border_color_opacity),
-                                        steps).tolist()
-            border_color2_opacitys = np.linspace(float(uncheck.pressed.border_color2_opacity),
-                                                float(check.rest.border_color2_opacity),
-                                                steps).tolist()
-        for i in range(steps):
-            def update(ii=i):
-                from easydict import EasyDict
-                tempcolor = EasyDict(
-                    {
-                        "back_color": back_colors[ii],
-                        "back_opacity": back_opacitys[ii],
-                        "border_color": border_colors[ii],
-                        "border_color_opacity": str(border_color_opacitys[ii]),
-                        "border_color2": border_colors2[ii],
-                        "border_color2_opacity": str(border_color2_opacitys[ii]),
-                        "border_width": 1,
-                        "text_color": text_colors[ii],
-                        "radius": 6,
-                    }
+        if not animation_steps == 0 or not animation_step_time == 0:
+            steps = animation_steps
+            if uncheck.pressed.border_color2 is None:
+                uncheck.pressed.border_color2 = uncheck.pressed.border_color
+            if check.pressed.border_color2  is None:
+                check.pressed.border_color2 = check.pressed.border_color
+            if uncheck.pressed.border_color2_opacity is None:
+                uncheck.pressed.border_color2_opacity = uncheck.pressed.border_color_opacity
+            if check.pressed.border_color2_opacity is None:
+                check.pressed.border_color2_opacity = check.pressed.border_color_opacity
+            if self.attributes.checked:
+                self.attributes.checked = False
+                back_colors = self.generate_hex2hex(
+                    check.pressed.back_color, uncheck.rest.back_color, steps
+                )
+                border_colors = self.generate_hex2hex(
+                    check.pressed.border_color, uncheck.rest.border_color, steps
                 )
-                self._draw(None, tempcolor)
-            self.after(i*10, update)
-        self.after(steps*10+10, lambda: self._draw(None, None))
+                border_colors2 = self.generate_hex2hex(
+                    check.pressed.border_color2, uncheck.rest.border_color2, steps
+                )
+                text_colors = self.generate_hex2hex(
+                    check.pressed.text_color, uncheck.rest.text_color, steps
+                )
+                import numpy as np
+                back_opacitys = np.linspace(
+                    float(check.pressed.back_opacity), float(uncheck.rest.back_opacity), steps).tolist()
+                border_color_opacitys = np.linspace(
+                    float(check.pressed.border_color_opacity), float(uncheck.rest.border_color_opacity), steps).tolist()
+                border_color2_opacitys = np.linspace(
+                    float(check.pressed.border_color2_opacity), float(uncheck.rest.border_color2_opacity), steps).tolist()
+            else:
+                self.attributes.checked = True
+                back_colors = self.generate_hex2hex(
+                    uncheck.pressed.back_color, check.rest.back_color, steps
+                )
+                border_colors = self.generate_hex2hex(
+                    uncheck.pressed.back_color, check.rest.back_color, steps
+                )
+                border_colors2 = self.generate_hex2hex(
+                    uncheck.pressed.border_color2, check.rest.border_color2, steps
+                )
+                text_colors = self.generate_hex2hex(
+                    uncheck.pressed.text_color, check.rest.text_color, steps
+                )
+                import numpy as np
+                back_opacitys = np.linspace(float(uncheck.pressed.back_opacity), float(check.rest.back_opacity),
+                                            steps).tolist()
+                border_color_opacitys = np.linspace(float(uncheck.pressed.border_color_opacity), float(check.rest.border_color_opacity),
+                                            steps).tolist()
+                border_color2_opacitys = np.linspace(float(uncheck.pressed.border_color2_opacity),
+                                                    float(check.rest.border_color2_opacity),
+                                                    steps).tolist()
+            for i in range(steps):
+                def update(ii=i):
+                    from easydict import EasyDict
+                    tempcolor = EasyDict(
+                        {
+                            "back_color": back_colors[ii],
+                            "back_opacity": back_opacitys[ii],
+                            "border_color": border_colors[ii],
+                            "border_color_opacity": str(border_color_opacitys[ii]),
+                            "border_color2": border_colors2[ii],
+                            "border_color2_opacity": str(border_color2_opacitys[ii]),
+                            "border_width": 1,
+                            "text_color": text_colors[ii],
+                            "radius": 6,
+                        }
+                    )
+                    self._draw(None, tempcolor)
+                self.after(i*animation_step_time, update)
+            self.after(steps*animation_step_time+10, lambda: self._draw(None, None))
+        else:
+            if self.attributes.checked:
+                self.attributes.checked = False
+            else:
+                self.attributes.checked = True

tkflu/tooltip.py

@@ -1,5 +1,6 @@
 from .popupwindow import FluPopupWindow
 from tkinter import Event, Widget
+import sys
 
 
 class FluToolTip(FluPopupWindow):
@@ -26,7 +27,7 @@ class FluToolTip(FluPopupWindow):
         self._widget.bind('<Enter>', self.enter, add="+")
         self._widget.bind('<Leave>', self.leave, add="+")
 
-        #self.theme(mode)
+        self.theme(mode)
 
     def enter(self, event: Event):
         def check() -> None:
@@ -44,10 +45,12 @@ class FluToolTip(FluPopupWindow):
 
                 # 渐显动画
                 def fade_in(step=0):
-                    alpha = step / 10  # 分10步从0到1
+                    FRAMES_COUNT = 20
+                    alpha = step / FRAMES_COUNT  # 按帧数变化，从0到1
                     self.wm_attributes("-alpha", alpha)
-                    if step < 10:
-                        self.after(int(round(self._show_time/10)), lambda: fade_in(step + 1))  # 每50ms增加一次透明度
+                    if step < FRAMES_COUNT:
+                        # 每执行一次，增加一次透明度，间隔由帧数决定
+                        self.after(int(round(self._show_time/FRAMES_COUNT)), lambda: fade_in(step + 1))
 
                 fade_in()  # 启动动画
 
@@ -103,7 +106,7 @@ class FluToolTip2(FluPopupWindow):
         self._widget.bind('<Leave>', self.hide, add="+")
         self._widget.bind('<Motion>', self.move, add="+")
 
-        #self.theme(mode)
+        self.theme(mode)
 
     def show(self, event: Event):
         self.popup(
@@ -127,7 +130,9 @@ class FluToolTip2(FluPopupWindow):
         self.configure(
             background=n["back_color"]
         )
-        self.wm_attributes("-transparentcolor", n["back_color"])
+
+        if sys.platform == "win32": # Only Windows supports the transparentcolor attribute
+            self.wm_attributes("-transparentcolor", n["back_color"])
         #print(n["back_color"])
         if hasattr(self, "_frame"):
             self._frame.dconfigure(