spacr 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

spacr/gui_elements.py

@@ -1,4 +1,4 @@
-import os, threading, time, sqlite3
+import os, threading, time, sqlite3, webbrowser
 import tkinter as tk
 from tkinter import ttk
 import tkinter.font as tkFont
@@ -17,7 +17,21 @@ from scipy.ndimage import binary_fill_holes, label
 from tkinter import ttk, scrolledtext
 
 def set_default_font(root, font_name="Arial", size=12):
-    default_font = (font_name, size)
+
+    # Define default_font before the condition
+    default_font = ("Arial", size)
+    
+    if font_name == 'OpenSans':
+        try:
+            font_path = os.path.join(os.path.dirname(__file__), 'resources/font/open_sans/static/OpenSans-Regular.ttf')
+            default_font = tkFont.Font(family=font_name, size=size, file=font_path)
+        except Exception as e:
+            print(f"Failed to load OpenSans font: {e}")
+            # Fallback to a default font in case of an error
+            default_font = ("Arial", size)
+    else:
+        default_font = (font_name, size)
+    
     root.option_add("*Font", default_font)
     root.option_add("*TButton.Font", default_font)
     root.option_add("*TLabel.Font", default_font)
@@ -47,29 +61,11 @@ def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font
     style.configure('TEntry', padding=padding)
     style.configure('Spacr.TEntry', padding=padding)
     style.configure('Custom.TLabel', padding=padding)
-    #style.configure('Spacr.TCheckbutton', padding=padding)
     style.configure('TButton', padding=padding)
-
     style.configure('TFrame', background=bg_color)
     style.configure('TPanedwindow', background=bg_color)
     style.configure('TLabel', background=bg_color, foreground=fg_color, font=font_style)
 
-
-    #style.configure('Custom.TLabel', padding='5 5 5 5', borderwidth=1, relief='flat', background=bg_color, foreground=fg_color, font=font_style)
-    #style.configure('Spacr.TCheckbutton', background=bg_color, foreground=fg_color, indicatoron=False, relief='flat', font="15")
-    #style.map('Spacr.TCheckbutton', background=[('selected', bg_color), ('active', bg_color)], foreground=[('selected', fg_color), ('active', fg_color)])
-    
-
-    #style.configure('TNotebook', background=bg_color, tabmargins=[2, 5, 2, 0])
-    #style.configure('TNotebook.Tab', background=bg_color, foreground=fg_color, padding=[5, 5], font=font_style)
-    #style.map('TNotebook.Tab', background=[('selected', active_color), ('active', active_color)], foreground=[('selected', fg_color), ('active', fg_color)])
-    #style.configure('TButton', background=bg_color, foreground=fg_color, padding='5 5 5 5', font=font_style)
-    #style.map('TButton', background=[('active', active_color), ('disabled', inactive_color)])
-    #style.configure('Vertical.TScrollbar', background=bg_color, troughcolor=bg_color, bordercolor=bg_color)
-    #style.configure('Horizontal.TScrollbar', background=bg_color, troughcolor=bg_color, bordercolor=bg_color)
-    #style.configure('Custom.TLabelFrame', font=(font_family, font_size, 'bold'), background=bg_color, foreground='white', relief='solid', borderwidth=1)
-    #style.configure('Custom.TLabelFrame.Label', background=bg_color, foreground='white', font=(font_family, font_size, 'bold'))
-
     if parent_frame:
         parent_frame.configure(bg=bg_color)
         parent_frame.grid_rowconfigure(0, weight=1)
@@ -99,8 +95,101 @@ def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font
 
     return {'font_family': font_family, 'font_size': font_size, 'bg_color': bg_color, 'fg_color': fg_color, 'active_color': active_color, 'inactive_color': inactive_color}
 
+class spacrContainer(tk.Frame):
+    def __init__(self, parent, orient=tk.VERTICAL, bg=None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        self.orient = orient
+        self.bg = bg if bg else 'lightgrey'
+        self.sash_thickness = 10
+
+        self.panes = []
+        self.sashes = []
+        self.bind("<Configure>", self.on_configure)
+
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+
+    def add(self, widget, stretch='always'):
+        print(f"Adding widget: {widget} with stretch: {stretch}")
+        pane = tk.Frame(self, bg=self.bg)
+        pane.grid_propagate(False)
+        widget.grid(in_=pane, sticky="nsew")  # Use grid for the widget within the pane
+        self.panes.append((pane, widget))
+
+        if len(self.panes) > 1:
+            self.create_sash()
+
+        self.reposition_panes()
+
+    def create_sash(self):
+        sash = tk.Frame(self, bg=self.bg, cursor='sb_v_double_arrow' if self.orient == tk.VERTICAL else 'sb_h_double_arrow', height=self.sash_thickness, width=self.sash_thickness)
+        sash.bind("<Enter>", self.on_enter_sash)
+        sash.bind("<Leave>", self.on_leave_sash)
+        sash.bind("<ButtonPress-1>", self.start_resize)
+        self.sashes.append(sash)
+
+    def reposition_panes(self):
+        if not self.panes:
+            return
+
+        total_size = self.winfo_height() if self.orient == tk.VERTICAL else self.winfo_width()
+        pane_size = total_size // len(self.panes)
+
+        print(f"Total size: {total_size}, Pane size: {pane_size}, Number of panes: {len(self.panes)}")
+
+        for i, (pane, widget) in enumerate(self.panes):
+            if self.orient == tk.VERTICAL:
+                pane.grid(row=i * 2, column=0, sticky="nsew", pady=(0, self.sash_thickness if i < len(self.panes) - 1 else 0))
+            else:
+                pane.grid(row=0, column=i * 2, sticky="nsew", padx=(0, self.sash_thickness if i < len(self.panes) - 1 else 0))
+
+        for i, sash in enumerate(self.sashes):
+            if self.orient == tk.VERTICAL:
+                sash.grid(row=(i * 2) + 1, column=0, sticky="ew")
+            else:
+                sash.grid(row=0, column=(i * 2) + 1, sticky="ns")
+
+    def on_configure(self, event):
+        print(f"Configuring container: {self}")
+        self.reposition_panes()
+
+    def on_enter_sash(self, event):
+        event.widget.config(bg='blue')
+
+    def on_leave_sash(self, event):
+        event.widget.config(bg=self.bg)
+
+    def start_resize(self, event):
+        sash = event.widget
+        self.start_pos = event.y_root if self.orient == tk.VERTICAL else event.x_root
+        self.start_size = sash.winfo_y() if self.orient == tk.VERTICAL else sash.winfo_x()
+        sash.bind("<B1-Motion>", self.perform_resize)
+
+    def perform_resize(self, event):
+        sash = event.widget
+        delta = (event.y_root - self.start_pos) if self.orient == tk.VERTICAL else (event.x_root - self.start_pos)
+        new_size = self.start_size + delta
+
+        for i, (pane, widget) in enumerate(self.panes):
+            if self.orient == tk.VERTICAL:
+                new_row = max(0, new_size // self.sash_thickness)
+                if pane.winfo_y() >= new_size:
+                    pane.grid_configure(row=new_row)
+                elif pane.winfo_y() < new_size and i > 0:
+                    previous_row = max(0, (new_size - pane.winfo_height()) // self.sash_thickness)
+                    self.panes[i - 1][0].grid_configure(row=previous_row)
+            else:
+                new_col = max(0, new_size // self.sash_thickness)
+                if pane.winfo_x() >= new_size:
+                    pane.grid_configure(column=new_col)
+                elif pane.winfo_x() < new_size and i > 0:
+                    previous_col = max(0, (new_size - pane.winfo_width()) // self.sash_thickness)
+                    self.panes[i - 1][0].grid_configure(column=previous_col)
+
+        self.reposition_panes()
+
 class spacrEntry(tk.Frame):
-    def __init__(self, parent, textvariable=None, outline=False, *args, **kwargs):
+    def __init__(self, parent, textvariable=None, outline=False, width=None, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
         
         # Set dark style
@@ -116,13 +205,17 @@ class spacrEntry(tk.Frame):
         self.configure(bg=style_out['bg_color'])
 
         # Create a canvas for the rounded rectangle background
-        self.canvas_width = 220  # Adjusted for padding
+        if width is None:
+            self.canvas_width = 220  # Adjusted for padding
+        else:
+            self.canvas_width = width
         self.canvas_height = 40   # Adjusted for padding
         self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, bd=0, highlightthickness=0, relief='ridge', bg=style_out['bg_color'])
         self.canvas.pack()
         
+        # Create the entry widget
         self.entry = tk.Entry(self, textvariable=textvariable, bd=0, highlightthickness=0, fg=self.fg_color, font=(self.font_family, self.font_size), bg=self.bg_color)
-        self.entry.place(relx=0.5, rely=0.5, anchor=tk.CENTER, width=190, height=20)  # Centered positioning
+        self.entry.place(relx=0.5, rely=0.5, anchor=tk.CENTER, width=self.canvas_width - 30, height=20)  # Centered positioning
         
         # Bind events to change the background color on focus
         self.entry.bind("<FocusIn>", self.on_focus_in)
@@ -133,7 +226,7 @@ class spacrEntry(tk.Frame):
     def draw_rounded_rectangle(self, color):
         radius = 15  # Increased radius for more rounded corners
         x0, y0 = 10, 5
-        x1, y1 = 210, 35
+        x1, y1 = self.canvas_width - 10, self.canvas_height - 5
         self.canvas.delete("all")
         self.canvas.create_arc((x0, y0, x0 + radius, y0 + radius), start=90, extent=90, fill=color, outline=color)
         self.canvas.create_arc((x1 - radius, y0, x1, y0 + radius), start=0, extent=90, fill=color, outline=color)
@@ -201,7 +294,7 @@ class spacrCheck(tk.Frame):
         self.variable.set(not self.variable.get())
 
 class spacrCombo(tk.Frame):
-    def __init__(self, parent, textvariable=None, values=None, *args, **kwargs):
+    def __init__(self, parent, textvariable=None, values=None, width=None, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
         
         # Set dark style
@@ -216,7 +309,7 @@ class spacrCombo(tk.Frame):
         self.values = values or []
 
         # Create a canvas for the rounded rectangle background
-        self.canvas_width = 220  # Adjusted for padding
+        self.canvas_width = width if width is not None else 220  # Adjusted for padding
         self.canvas_height = 40   # Adjusted for padding
         self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, bd=0, highlightthickness=0, relief='ridge', bg=self.bg_color)
         self.canvas.pack()
@@ -239,7 +332,7 @@ class spacrCombo(tk.Frame):
     def draw_rounded_rectangle(self, color):
         radius = 15  # Increased radius for more rounded corners
         x0, y0 = 10, 5
-        x1, y1 = 210, 35
+        x1, y1 = self.canvas_width - 10, self.canvas_height - 5
         self.canvas.delete("all")
         self.canvas.create_arc((x0, y0, x0 + radius, y0 + radius), start=90, extent=90, fill=color, outline=color)
         self.canvas.create_arc((x1 - radius, y0, x1, y0 + radius), start=0, extent=90, fill=color, outline=color)
@@ -305,6 +398,73 @@ class spacrDropdownMenu(tk.OptionMenu):
         # Create custom button
         self.create_custom_button()
 
+    def create_custom_button(self):
+        self.canvas_width = self.winfo_reqwidth() + 20  # Adjust width based on required size
+        self.canvas_height = 40  # Adjust the height as needed
+        self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, bd=0, highlightthickness=0, relief='ridge', bg='#2B2B2B')
+        self.canvas.pack()
+        self.label = tk.Label(self.canvas, text="Settings Category", bg='#2B2B2B', fg='#ffffff', font=('Arial', 12))
+        self.label.place(relx=0.5, rely=0.5, anchor=tk.CENTER)
+        self.draw_rounded_rectangle('#2B2B2B')
+
+        # Bind the click event to open the dropdown menu
+        self.canvas.bind("<Button-1>", self.on_click)
+        self.label.bind("<Button-1>", self.on_click)
+
+    def draw_rounded_rectangle(self, color):
+        radius = 15
+        x0, y0 = 10, 5
+        x1, y1 = self.canvas_width - 10, self.canvas_height - 5  # Adjust based on canvas size
+
+        self.canvas.delete("all")
+
+        # Create the rounded rectangle
+        self.canvas.create_arc(x0, y0, x0 + 2 * radius, y0 + 2 * radius, start=90, extent=90, fill=color, outline=color)
+        self.canvas.create_arc(x1 - 2 * radius, y0, x1, y0 + 2 * radius, start=0, extent=90, fill=color, outline=color)
+        self.canvas.create_arc(x0, y1 - 2 * radius, x0 + 2 * radius, y1, start=180, extent=90, fill=color, outline=color)
+        self.canvas.create_arc(x1 - 2 * radius, y1 - 2 * radius, x1, y1, start=270, extent=90, fill=color, outline=color)
+
+        self.canvas.create_rectangle(x0 + radius, y0, x1 - radius, y1, fill=color, outline=color)
+        self.canvas.create_rectangle(x0, y0 + radius, x1, y1 - radius, fill=color, outline=color)
+
+        self.label.config(bg=color)  # Update label background to match rectangle color
+
+    def on_click(self, event):
+        self.post_menu()
+
+    def post_menu(self):
+        x, y, width, height = self.winfo_rootx(), self.winfo_rooty(), self.winfo_width(), self.winfo_height()
+        self.menu.post(x, y + height)
+
+    def update_styles(self, active_categories=None):
+        style = ttk.Style()
+        style_out = set_dark_style(style, widgets=[self])
+        self.menu = self['menu']
+        style_out = set_dark_style(style, widgets=[self.menu])
+
+        if active_categories is not None:
+            for idx in range(self.menu.index("end") + 1):
+                option = self.menu.entrycget(idx, "label")
+                if option in active_categories:
+                    self.menu.entryconfig(idx, background=style_out['active_color'], foreground=style_out['fg_color'])
+                else:
+                    self.menu.entryconfig(idx, background=style_out['bg_color'], foreground=style_out['fg_color'])
+
+
+
+class spacrDropdownMenu_v1(tk.OptionMenu):
+    def __init__(self, parent, variable, options, command=None, **kwargs):
+        self.variable = variable
+        self.variable.set("Settings Category")
+        super().__init__(parent, self.variable, *options, command=command, **kwargs)
+        self.update_styles()
+
+        # Hide the original button
+        self.configure(highlightthickness=0, relief='flat', bg='#2B2B2B', fg='#2B2B2B')
+
+        # Create custom button
+        self.create_custom_button()
+
     def create_custom_button(self):
         self.canvas_width = self.winfo_reqwidth()  # Use the required width of the widget
         self.canvas_height = 40  # Adjust the height as needed
@@ -363,12 +523,12 @@ class spacrCheckbutton(ttk.Checkbutton):
         _ = set_dark_style(style, widgets=[self])
 
 class spacrProgressBar(ttk.Progressbar):
-    def __init__(self, parent, *args, **kwargs):
+    def __init__(self, parent, label=True, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
 
         # Get the style colors
         style_out = set_dark_style(ttk.Style())
-       
+
         self.fg_color = style_out['fg_color']
         self.bg_color = style_out['bg_color']
         self.active_color = style_out['active_color']
@@ -389,9 +549,13 @@ class spacrProgressBar(ttk.Progressbar):
         # Set initial value to 0
         self['value'] = 0
 
-        # Create the progress label
-        self.progress_label = tk.Label(parent, text="Processing: 0/0", anchor='w', justify='left', bg=self.inactive_color, fg=self.fg_color)
-        self.progress_label.grid(row=1, column=0, columnspan=2, pady=5, padx=5, sticky='ew')
+        # Track whether to show the progress label
+        self.label = label
+
+        # Create the progress label (defer placement)
+        if self.label:
+            self.progress_label = tk.Label(parent, text="Processing: 0/0", anchor='w', justify='left', bg=self.inactive_color, fg=self.fg_color)
+            self.progress_label.grid_forget()  # Temporarily hide it
 
         # Initialize attributes for time and operation
         self.operation_type = None
@@ -399,57 +563,141 @@ class spacrProgressBar(ttk.Progressbar):
         self.time_batch = None
         self.time_left = None
 
+    def set_label_position(self):
+        if self.label and self.progress_label:
+            row_info = self.grid_info().get('row', 0)
+            col_info = self.grid_info().get('column', 0)
+            col_span = self.grid_info().get('columnspan', 1)
+            self.progress_label.grid(row=row_info + 1, column=col_info, columnspan=col_span, pady=5, padx=5, sticky='ew')
+
     def update_label(self):
-        # Update the progress label with current progress and additional info
-        label_text = f"Processing: {self['value']}/{self['maximum']}"
-        if self.operation_type:
-            label_text += f", {self.operation_type}"
-        if self.time_image:
-            label_text += f", Time/image: {self.time_image:.3f} sec"
-        if self.time_batch:
-            label_text += f", Time/batch: {self.time_batch:.3f} sec"
-        if self.time_left:
-            label_text += f", Time_left: {self.time_left:.3f} min"
-        self.progress_label.config(text=label_text)
+        if self.label and self.progress_label:
+            # Update the progress label with current progress and additional info
+            label_text = f"Processing: {self['value']}/{self['maximum']}"
+            if self.operation_type:
+                label_text += f", {self.operation_type}"
+            if self.time_image:
+                label_text += f", Time/image: {self.time_image:.3f} sec"
+            if self.time_batch:
+                label_text += f", Time/batch: {self.time_batch:.3f} sec"
+            if self.time_left:
+                label_text += f", Time_left: {self.time_left:.3f} min"
+            self.progress_label.config(text=label_text)
+
+def spacrScrollbarStyle(style, inactive_color, active_color):
+    # Check if custom elements already exist to avoid duplication
+    if not style.element_names().count('custom.Vertical.Scrollbar.trough'):
+        style.element_create('custom.Vertical.Scrollbar.trough', 'from', 'clam')
+    if not style.element_names().count('custom.Vertical.Scrollbar.thumb'):
+        style.element_create('custom.Vertical.Scrollbar.thumb', 'from', 'clam')
+
+    style.layout('Custom.Vertical.TScrollbar',
+                 [('Vertical.Scrollbar.trough', {'children': [('Vertical.Scrollbar.thumb', {'expand': '1', 'sticky': 'nswe'})], 'sticky': 'ns'})])
+
+    style.configure('Custom.Vertical.TScrollbar',
+                    background=inactive_color,
+                    troughcolor=inactive_color,
+                    bordercolor=inactive_color,
+                    lightcolor=inactive_color,
+                    darkcolor=inactive_color)
+
+    style.map('Custom.Vertical.TScrollbar',
+              background=[('!active', inactive_color), ('active', active_color)],
+              troughcolor=[('!active', inactive_color), ('active', inactive_color)],
+              bordercolor=[('!active', inactive_color), ('active', inactive_color)],
+              lightcolor=[('!active', inactive_color), ('active', active_color)],
+              darkcolor=[('!active', inactive_color), ('active', active_color)])
 
 class spacrFrame(ttk.Frame):
-    def __init__(self, container, width=None, *args, bg='black', **kwargs):
+    def __init__(self, container, width=None, *args, bg='black', radius=20, scrollbar=True, textbox=False, **kwargs):
         super().__init__(container, *args, **kwargs)
         self.configure(style='TFrame')
         if width is None:
             screen_width = self.winfo_screenwidth()
             width = screen_width // 4
-        canvas = tk.Canvas(self, bg=bg, width=width)
-        scrollbar = ttk.Scrollbar(self, orient="vertical", command=canvas.yview)
+
+        # Create the canvas
+        canvas = tk.Canvas(self, bg=bg, width=width, highlightthickness=0)
+        self.rounded_rectangle(canvas, 0, 0, width, self.winfo_screenheight(), radius, fill=bg)
+
+        # Define scrollbar styles
+        style_out = set_dark_style(ttk.Style())
+        self.inactive_color = style_out['inactive_color']
+        self.active_color = style_out['active_color']
+        self.fg_color = style_out['fg_color']  # Foreground color for text
+
+        # Set custom scrollbar style
+        style = ttk.Style()
+        spacrScrollbarStyle(style, self.inactive_color, self.active_color)
+
+        # Create scrollbar with custom style if scrollbar option is True
+        if scrollbar:
+            scrollbar_widget = ttk.Scrollbar(self, orient="vertical", command=canvas.yview, style='Custom.Vertical.TScrollbar')
+        
+        if textbox:
+            self.scrollable_frame = tk.Text(canvas, bg=bg, fg=self.fg_color, wrap=tk.WORD)
+        else:
+            self.scrollable_frame = ttk.Frame(canvas, style='TFrame')
         
-        self.scrollable_frame = ttk.Frame(canvas, style='TFrame')
         self.scrollable_frame.bind(
             "<Configure>",
             lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
         )
         canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
-        canvas.configure(yscrollcommand=scrollbar.set)
+        if scrollbar:
+            canvas.configure(yscrollcommand=scrollbar_widget.set)
         
         canvas.grid(row=0, column=0, sticky="nsew")
-        scrollbar.grid(row=0, column=1, sticky="ns")
+        if scrollbar:
+            scrollbar_widget.grid(row=0, column=1, sticky="ns")
 
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
-        self.grid_columnconfigure(1, weight=0)
+        if scrollbar:
+            self.grid_columnconfigure(1, weight=0)
         
-        style = ttk.Style()
-        _ = set_dark_style(style, containers=[self], widgets=[canvas, scrollbar, self.scrollable_frame])
+        _ = set_dark_style(style, containers=[self], widgets=[canvas, self.scrollable_frame])
+        if scrollbar:
+            _ = set_dark_style(style, widgets=[scrollbar_widget])
+
+    def rounded_rectangle(self, canvas, x1, y1, x2, y2, radius=20, **kwargs):
+        points = [
+            x1 + radius, y1,
+            x2 - radius, y1,
+            x2 - radius, y1,
+            x2, y1,
+            x2, y1 + radius,
+            x2, y2 - radius,
+            x2, y2 - radius,
+            x2, y2,
+            x2 - radius, y2,
+            x1 + radius, y2,
+            x1 + radius, y2,
+            x1, y2,
+            x1, y2 - radius,
+            x1, y2 - radius,
+            x1, y1 + radius,
+            x1, y1 + radius,
+            x1, y1
+        ]
+        return canvas.create_polygon(points, **kwargs, smooth=True)
 
 class spacrLabel(tk.Frame):
-    def __init__(self, parent, text="", font=None, style=None, align="right", **kwargs):
+    def __init__(self, parent, text="", font=None, style=None, align="right", height=None, **kwargs):
         valid_kwargs = {k: v for k, v in kwargs.items() if k not in ['foreground', 'background', 'font', 'anchor', 'justify', 'wraplength']}
         super().__init__(parent, **valid_kwargs)
         
         self.text = text
         self.align = align
-        screen_height = self.winfo_screenheight()
-        label_height = screen_height // 50
-        label_width = label_height * 10
+
+        if height is None:
+            screen_height = self.winfo_screenheight()
+            label_height = screen_height // 50
+            label_width = label_height * 10
+        else:
+            label_height = height
+            label_width = label_height * 10
+
         style_out = set_dark_style(ttk.Style())
 
         self.canvas = tk.Canvas(self, width=label_width, height=label_height, highlightthickness=0, bg=style_out['bg_color'])
@@ -484,7 +732,7 @@ class spacrLabel(tk.Frame):
             self.canvas.itemconfig(self.label_text, text=text)
 
 class spacrButton(tk.Frame):
-    def __init__(self, parent, text="", command=None, font=None, icon_name=None, size=50, show_text=True, outline=False, *args, **kwargs):
+    def __init__(self, parent, text="", command=None, font=None, icon_name=None, size=50, show_text=True, outline=False, animation=True, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
         
         self.text = text.capitalize()  # Capitalize only the first letter of the text
@@ -493,6 +741,7 @@ class spacrButton(tk.Frame):
         self.size = size
         self.show_text = show_text
         self.outline = outline
+        self.animation = animation  # Add animation attribute
 
         style_out = set_dark_style(ttk.Style())
 
@@ -559,13 +808,13 @@ class spacrButton(tk.Frame):
     def on_enter(self, event=None):
         self.canvas.itemconfig(self.button_bg, fill=self.active_color)
         self.update_description(event)
-        if not self.is_zoomed_in:
+        if self.animation and not self.is_zoomed_in:
             self.animate_zoom(0.85)  # Zoom in the icon to 85% of button size
 
     def on_leave(self, event=None):
         self.canvas.itemconfig(self.button_bg, fill=self.inactive_color)
         self.clear_description(event)
-        if self.is_zoomed_in:
+        if self.animation and self.is_zoomed_in:
             self.animate_zoom(0.65)  # Reset the icon size to 65% of button size
 
     def on_click(self, event=None):
@@ -1990,6 +2239,7 @@ def create_menu_bar(root):
 
     # Add a separator and an exit option
     app_menu.add_separator()
+    app_menu.add_command(label="Help", command=lambda: webbrowser.open("https://readthedocs.org/projects/spacr/badge/?version=latest"))
     app_menu.add_command(label="Exit", command=root.quit)
 
     # Configure the menu for the root window