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

spacr/gui_elements.py

@@ -1,7 +1,9 @@
-import os, threading, time, sqlite3
+import os, threading, time, sqlite3, webbrowser, pyautogui
 import tkinter as tk
 from tkinter import ttk
 import tkinter.font as tkFont
+from tkinter import filedialog
+from tkinter import font
 from queue import Queue
 from tkinter import Label, Frame, Button
 import numpy as np
@@ -15,15 +17,30 @@ from skimage.draw import polygon, line
 from skimage.transform import resize
 from scipy.ndimage import binary_fill_holes, label
 from tkinter import ttk, scrolledtext
+fig = None
 
-def set_default_font(root, font_name="Arial", size=12):
-    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)
-    root.option_add("*TEntry.Font", default_font)
+def set_element_size():
+
+    screen_width, screen_height = pyautogui.size()
+    screen_area = screen_width * screen_height
+    
+    # Calculate sizes based on screen dimensions
+    btn_size = int((screen_area * 0.002) ** 0.5)  # Button size as a fraction of screen area
+    bar_size = screen_height // 20  # Bar size based on screen height
+    settings_width = screen_width // 4  # Settings panel width as a fraction of screen width
+    panel_width = screen_width - settings_width  # Panel width as a fraction of screen width
+    panel_height = screen_height // 6  # Panel height as a fraction of screen height
+    
+    size_dict = {
+        'btn_size': btn_size,
+        'bar_size': bar_size,
+        'settings_width': settings_width,
+        'panel_width': panel_width,
+        'panel_height': panel_height
+    }
+    return size_dict
     
-def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font_family="Arial", font_size=12, bg_color='black', fg_color='white', active_color='blue', inactive_color='dark_gray'):
+def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font_family="OpenSans", font_size=12, bg_color='black', fg_color='white', active_color='blue', inactive_color='dark_gray'):
 
     if active_color == 'teal':
         active_color = '#008080'
@@ -39,6 +56,11 @@ def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font
     padding = '5 5 5 5'
     font_style = tkFont.Font(family=font_family, size=font_size)
 
+    if font_family == 'OpenSans':
+        font_loader = spacrFont(font_name='OpenSans', font_style='Regular', font_size=12)
+    else:
+        font_loader = None
+        
     style.theme_use('clam')
     
     style.configure('TEntry', padding=padding)
@@ -47,28 +69,13 @@ 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 font_loader:
+        style.configure('TLabel', background=bg_color, foreground=fg_color, font=font_loader.get_font(size=font_size))
+    else:
+        style.configure('TLabel', background=bg_color, foreground=fg_color, font=(font_family, font_size))
 
     if parent_frame:
         parent_frame.configure(bg=bg_color)
@@ -89,18 +96,193 @@ def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font
             if isinstance(widget, (tk.Label, tk.Button, tk.Frame, ttk.LabelFrame, tk.Canvas)):
                 widget.configure(bg=bg_color)
             if isinstance(widget, (tk.Label, tk.Button)):
-                widget.configure(fg=fg_color, font=(font_family, font_size))
+                if font_loader:
+                    widget.configure(fg=fg_color, font=font_loader.get_font(size=font_size))
+                else:
+                    widget.configure(fg=fg_color, font=(font_family, font_size))
             if isinstance(widget, scrolledtext.ScrolledText):
                 widget.configure(bg=bg_color, fg=fg_color, insertbackground=fg_color)
             if isinstance(widget, tk.OptionMenu):
-                widget.configure(bg=bg_color, fg=fg_color, font=(font_family, font_size))
+                if font_loader:
+                    widget.configure(bg=bg_color, fg=fg_color, font=font_loader.get_font(size=font_size))
+                else:
+                    widget.configure(bg=bg_color, fg=fg_color, font=(font_family, font_size))
                 menu = widget['menu']
-                menu.configure(bg=bg_color, fg=fg_color, font=(font_family, font_size))
+                if font_loader:
+                    menu.configure(bg=bg_color, fg=fg_color, font=font_loader.get_font(size=font_size))
+                else:
+                    menu.configure(bg=bg_color, fg=fg_color, font=(font_family, font_size))
+
+    return {'font_loader':font_loader, '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 spacrFont:
+    def __init__(self, font_name, font_style, font_size=12):
+        """
+        Initializes the FontLoader class.
+
+        Parameters:
+        - font_name: str, the name of the font (e.g., 'OpenSans').
+        - font_style: str, the style of the font (e.g., 'Regular', 'Bold').
+        - font_size: int, the size of the font (default: 12).
+        """
+        self.font_name = font_name
+        self.font_style = font_style
+        self.font_size = font_size
+
+        # Determine the path based on the font name and style
+        self.font_path = self.get_font_path(font_name, font_style)
+
+        # Register the font with Tkinter
+        self.load_font()
+
+    def get_font_path(self, font_name, font_style):
+        """
+        Returns the font path based on the font name and style.
+
+        Parameters:
+        - font_name: str, the name of the font.
+        - font_style: str, the style of the font.
+
+        Returns:
+        - str, the path to the font file.
+        """
+        base_dir = os.path.dirname(__file__)
+        
+        if font_name == 'OpenSans':
+            if font_style == 'Regular':
+                return os.path.join(base_dir, 'resources/font/open_sans/static/OpenSans-Regular.ttf')
+            elif font_style == 'Bold':
+                return os.path.join(base_dir, 'resources/font/open_sans/static/OpenSans-Bold.ttf')
+            elif font_style == 'Italic':
+                return os.path.join(base_dir, 'resources/font/open_sans/static/OpenSans-Italic.ttf')
+            # Add more styles as needed
+        # Add more fonts as needed
+        
+        raise ValueError(f"Font '{font_name}' with style '{font_style}' not found.")
+
+    def load_font(self):
+        """
+        Loads the font into Tkinter.
+        """
+        try:
+            font.Font(family=self.font_name, size=self.font_size)
+        except tk.TclError:
+            # Load the font manually if it's not already loaded
+            self.tk_font = font.Font(
+                name=self.font_name,
+                file=self.font_path,
+                size=self.font_size
+            )
+
+    def get_font(self, size=None):
+        """
+        Returns the font in the specified size.
+
+        Parameters:
+        - size: int, the size of the font (optional).
+
+        Returns:
+        - tkFont.Font object.
+        """
+        if size is None:
+            size = self.font_size
+        return font.Font(family=self.font_name, size=size)
+
+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
 
-    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}
+        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
@@ -111,18 +293,26 @@ class spacrEntry(tk.Frame):
         self.outline = outline
         self.font_family = style_out['font_family']
         self.font_size = style_out['font_size']
+        self.font_loader = style_out['font_loader']
         
         # Set the background color of the 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()
         
-        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
+        # Create the entry widget
+        if self.font_loader:
+            self.entry = tk.Entry(self, textvariable=textvariable, bd=0, highlightthickness=0, fg=self.fg_color, font=self.font_loader.get_font(size=self.font_size), bg=self.bg_color)
+        else:
+            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=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 +323,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 +391,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
@@ -212,11 +402,12 @@ class spacrCombo(tk.Frame):
         self.inactive_color = style_out['inactive_color']
         self.font_family = style_out['font_family']
         self.font_size = style_out['font_size']
+        self.font_loader = style_out['font_loader']
 
         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()
@@ -225,7 +416,10 @@ class spacrCombo(tk.Frame):
         self.selected_value = self.var.get()
         
         # Create the label to display the selected value
-        self.label = tk.Label(self, text=self.selected_value, bg=self.inactive_color, fg=self.fg_color, font=(self.font_family, self.font_size))
+        if self.font_loader:
+            self.label = tk.Label(self, text=self.selected_value, bg=self.inactive_color, fg=self.fg_color, font=self.font_loader.get_font(size=self.font_size))
+        else:
+            self.label = tk.Label(self, text=self.selected_value, bg=self.inactive_color, fg=self.fg_color, font=(self.font_family, self.font_size))
         self.label.place(relx=0.5, rely=0.5, anchor=tk.CENTER)
         
         # Bind events to open the dropdown menu
@@ -239,7 +433,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)
@@ -266,7 +460,10 @@ class spacrCombo(tk.Frame):
         
         for index, value in enumerate(self.values):
             display_text = value if value is not None else 'None'
-            item = tk.Label(self.dropdown_menu, text=display_text, bg=self.inactive_color, fg=self.fg_color, font=(self.font_family, self.font_size), anchor='w')
+            if self.font_loader:
+                item = tk.Label(self.dropdown_menu, text=display_text, bg=self.inactive_color, fg=self.fg_color, font=self.font_loader.get_font(size=self.font_size), anchor='w')
+            else:
+                item = tk.Label(self.dropdown_menu, text=display_text, bg=self.inactive_color, fg=self.fg_color, font=(self.font_family, self.font_size), anchor='w')
             item.pack(fill='both')
             item.bind("<Button-1>", lambda e, v=value: self.on_select(v))
             item.bind("<Enter>", lambda e, w=item: w.config(bg=self.active_color))
@@ -292,57 +489,102 @@ class spacrCombo(tk.Frame):
         self.label.config(text=display_text)
         self.selected_value = value
 
-class spacrDropdownMenu(tk.OptionMenu):
-    def __init__(self, parent, variable, options, command=None, **kwargs):
+class spacrDropdownMenu(tk.Frame):
+
+    def __init__(self, parent, variable, options, command=None, font=None, size=50, **kwargs):
+        super().__init__(parent, **kwargs)
         self.variable = variable
-        self.variable.set("Settings Category")
-        super().__init__(parent, self.variable, *options, command=command, **kwargs)
-        self.update_styles()
+        self.options = options
+        self.command = command
+        self.text = "Settings"
+        self.size = size
 
-        # Hide the original button
-        self.configure(highlightthickness=0, relief='flat', bg='#2B2B2B', fg='#2B2B2B')
+        # Apply dark style and get color settings
+        style_out = set_dark_style(ttk.Style())
+        self.font_size = style_out['font_size']
+        self.font_loader = style_out['font_loader']
 
-        # Create custom button
-        self.create_custom_button()
+        # Button size configuration
+        self.button_width = int(size * 3)
+        self.canvas_width = self.button_width + 4
+        self.canvas_height = self.size + 4
 
-    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
-        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')
+        # Create the canvas and rounded button
+        self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, highlightthickness=0, bg=style_out['bg_color'])
+        self.canvas.grid(row=0, column=0)
+
+        # Apply dark style and get color settings
+        color_settings = set_dark_style(ttk.Style(), containers=[self], widgets=[self.canvas])
+        self.inactive_color = color_settings['inactive_color']
+        self.active_color = color_settings['active_color']
+        self.fg_color = color_settings['fg_color']
+        self.bg_color = style_out['bg_color']
+
+        # Create the button with rounded edges
+        self.button_bg = self.create_rounded_rectangle(2, 2, self.button_width + 2, self.size + 2, radius=20, fill=self.inactive_color, outline=self.inactive_color)
+
+        # Create and place the label on the button
+        if self.font_loader:
+            self.font_style = self.font_loader.get_font(size=self.font_size)
+        else:
+            self.font_style = font if font else ("Arial", 12)
+
+        self.button_text = self.canvas.create_text(self.button_width // 2, self.size // 2 + 2, text=self.text, fill=self.fg_color, font=self.font_style, anchor="center")
 
-        # Bind the click event to open the dropdown menu
+        # Bind events for button behavior
+        self.bind("<Enter>", self.on_enter)
+        self.bind("<Leave>", self.on_leave)
+        self.bind("<Button-1>", self.on_click)
+        self.canvas.bind("<Enter>", self.on_enter)
+        self.canvas.bind("<Leave>", self.on_leave)
         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")
-        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)
-        self.canvas.create_arc((x0, y1 - radius, x0 + radius, y1), start=180, extent=90, fill=color, outline=color)
-        self.canvas.create_arc((x1 - radius, y1 - radius, x1, y1), start=270, extent=90, fill=color, outline=color)
-        self.canvas.create_rectangle((x0 + radius / 2, y0, x1 - radius / 2, y1), fill=color, outline=color)
-        self.canvas.create_rectangle((x0, y0 + radius / 2, x1, y1 - radius / 2), fill=color, outline=color)
-        self.label.config(bg=color)  # Update label background to match rectangle color
+        # Create a popup menu with the desired background color
+        self.menu = tk.Menu(self, tearoff=0, bg=self.bg_color, fg=self.fg_color)
+        for option in self.options:
+            self.menu.add_command(label=option, command=lambda opt=option: self.on_select(opt))
 
-    def on_click(self, event):
+    def create_rounded_rectangle(self, 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 self.canvas.create_polygon(points, **kwargs, smooth=True)
+
+    def on_enter(self, event=None):
+        self.canvas.itemconfig(self.button_bg, fill=self.active_color)
+
+    def on_leave(self, event=None):
+        self.canvas.itemconfig(self.button_bg, fill=self.inactive_color)
+
+    def on_click(self, event=None):
         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 on_select(self, option):
+        if self.command:
+            self.command(option)
+
     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])
+        style_out = set_dark_style(ttk.Style(), widgets=[self.menu])
 
         if active_categories is not None:
             for idx in range(self.menu.index("end") + 1):
@@ -363,99 +605,378 @@ 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']
         self.inactive_color = style_out['inactive_color']
+        self.font_size = style_out['font_size']
+        self.font_loader = style_out['font_loader']
 
         # Configure the style for the progress bar
         self.style = ttk.Style()
+        
+        # Remove any borders and ensure the active color fills the entire space
         self.style.configure(
             "spacr.Horizontal.TProgressbar",
-            troughcolor=self.bg_color,
-            background=self.active_color,
-            thickness=20,
-            troughrelief='flat',
-            borderwidth=0
+            troughcolor=self.inactive_color,       # Set the trough to bg color
+            background=self.active_color,    # Active part is the active color
+            borderwidth=0,                   # Remove border width
+            pbarrelief="flat",               # Flat relief for the progress bar
+            troughrelief="flat",             # Flat relief for the trough
+            thickness=20,                    # Set the thickness of the progress bar
+            darkcolor=self.active_color,     # Ensure darkcolor matches the active color
+            lightcolor=self.active_color,    # Ensure lightcolor matches the active color
+            bordercolor=self.bg_color        # Set the border color to the background color to hide it
         )
+
         self.configure(style="spacr.Horizontal.TProgressbar")
 
         # 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 with text wrapping
+        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,
+                wraplength=300,
+                font=self.font_loader.get_font(size=self.font_size)
+            )
+            self.progress_label.grid_forget()
 
         # Initialize attributes for time and operation
         self.operation_type = None
-        self.time_image = None
-        self.time_batch = None
-        self.time_left = None
+        self.additional_info = 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:
+            # Start with the base progress information
+            label_text = f"Processing: {self['value']}/{self['maximum']}"
+            
+            # Include the operation type if it exists
+            if self.operation_type:
+                label_text += f", {self.operation_type}"
+            
+            # Handle additional info without adding newlines
+            if hasattr(self, 'additional_info') and self.additional_info:
+                # Join all additional info items with a space and ensure they're on the same line
+                items = self.additional_info.split(", ")
+                formatted_additional_info = " ".join(items)
+
+                # Append the additional info to the label_text, ensuring it's all in one line
+                label_text += f" {formatted_additional_info.strip()}"
+
+            # Update the progress label
+            self.progress_label.config(text=label_text)
+
+class spacrSlider(tk.Frame):
+    def __init__(self, master=None, length=None, thickness=2, knob_radius=10, position="center", from_=0, to=100, value=None, show_index=False, command=None, **kwargs):
+        super().__init__(master, **kwargs)
+
+        self.specified_length = length  # Store the specified length, if any
+        self.knob_radius = knob_radius
+        self.thickness = thickness
+        self.knob_position = knob_radius  # Start at the beginning of the slider
+        self.slider_line = None
+        self.knob = None
+        self.position = position.lower()  # Store the position option
+        self.offset = 0  # Initialize offset
+        self.from_ = from_  # Minimum value of the slider
+        self.to = to  # Maximum value of the slider
+        self.value = value if value is not None else from_  # Initial value of the slider
+        self.show_index = show_index  # Whether to show the index Entry widget
+        self.command = command  # Callback function to handle value changes
+
+        # Initialize the style and 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']
+        self.inactive_color = style_out['inactive_color']
+
+        # Configure the frame's background color
+        self.configure(bg=self.bg_color)
+
+        # Create a frame for the slider and entry if needed
+        self.grid_columnconfigure(1, weight=1)
+
+        # Entry widget for showing and editing index, if enabled
+        if self.show_index:
+            self.index_var = tk.StringVar(value=str(int(self.value)))
+            self.index_entry = tk.Entry(self, textvariable=self.index_var, width=5, bg=self.bg_color, fg=self.fg_color, insertbackground=self.fg_color)
+            self.index_entry.grid(row=0, column=0, padx=5)
+            # Bind the entry to update the slider on change
+            self.index_entry.bind("<Return>", self.update_slider_from_entry)
+
+        # Create the slider canvas
+        self.canvas = tk.Canvas(self, height=knob_radius * 2, bg=self.bg_color, highlightthickness=0)
+        self.canvas.grid(row=0, column=1, sticky="ew")
+
+        # Set initial length to specified length or default value
+        self.length = self.specified_length if self.specified_length is not None else self.canvas.winfo_reqwidth()
+
+        # Calculate initial knob position based on the initial value
+        self.knob_position = self.value_to_position(self.value)
+
+        # Bind resize event to dynamically adjust the slider length if no length is specified
+        self.canvas.bind("<Configure>", self.resize_slider)
+
+        # Draw the slider components
+        self.draw_slider(inactive=True)
+
+        # Bind mouse events to the knob and slider
+        self.canvas.bind("<B1-Motion>", self.move_knob)
+        self.canvas.bind("<Button-1>", self.activate_knob)  # Activate knob on click
+        self.canvas.bind("<ButtonRelease-1>", self.release_knob)  # Trigger command on release
+
+    def resize_slider(self, event):
+        if self.specified_length is not None:
+            self.length = self.specified_length
+        else:
+            self.length = int(event.width * 0.9)  # 90% of the container width
+        
+        # Calculate the horizontal offset based on the position
+        if self.position == "center":
+            self.offset = (event.width - self.length) // 2
+        elif self.position == "right":
+            self.offset = event.width - self.length
+        else:  # position is "left"
+            self.offset = 0
+
+        # Update the knob position after resizing
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=True)
+
+    def value_to_position(self, value):
+        if self.to == self.from_:
+            return self.knob_radius
+        relative_value = (value - self.from_) / (self.to - self.from_)
+        return self.knob_radius + relative_value * (self.length - 2 * self.knob_radius)
+
+    def position_to_value(self, position):
+        if self.to == self.from_:
+            return self.from_
+        relative_position = (position - self.knob_radius) / (self.length - 2 * self.knob_radius)
+        return self.from_ + relative_position * (self.to - self.from_)
+
+    def draw_slider(self, inactive=False):
+        self.canvas.delete("all")
+
+        self.slider_line = self.canvas.create_line(
+            self.offset + self.knob_radius, 
+            self.knob_radius, 
+            self.offset + self.length - self.knob_radius, 
+            self.knob_radius, 
+            fill=self.fg_color, 
+            width=self.thickness
+        )
+
+        knob_color = self.inactive_color if inactive else self.active_color
+        self.knob = self.canvas.create_oval(
+            self.offset + self.knob_position - self.knob_radius, 
+            self.knob_radius - self.knob_radius, 
+            self.offset + self.knob_position + self.knob_radius, 
+            self.knob_radius + self.knob_radius, 
+            fill=knob_color, 
+            outline=""
+        )
+
+    def move_knob(self, event):
+        new_position = min(max(event.x - self.offset, self.knob_radius), self.length - self.knob_radius)
+        self.knob_position = new_position
+        self.value = self.position_to_value(self.knob_position)
+        self.canvas.coords(
+            self.knob, 
+            self.offset + self.knob_position - self.knob_radius, 
+            self.knob_radius - self.knob_radius, 
+            self.offset + self.knob_position + self.knob_radius, 
+            self.knob_radius + self.knob_radius
+        )
+        if self.show_index:
+            self.index_var.set(str(int(self.value)))
+
+    def activate_knob(self, event):
+        self.draw_slider(inactive=False)
+        self.move_knob(event)
+
+    def release_knob(self, event):
+        self.draw_slider(inactive=True)
+        if self.command:
+            self.command(self.value)  # Call the command with the final value when the knob is released
+
+    def set_to(self, new_to):
+        self.to = new_to
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=False)
+
+    def get(self):
+        return self.value
+
+    def set(self, value):
+        """Set the slider's value and update the knob position."""
+        self.value = max(self.from_, min(value, self.to))  # Ensure the value is within bounds
+        self.knob_position = self.value_to_position(self.value)
+        self.draw_slider(inactive=False)
+        if self.show_index:
+            self.index_var.set(str(int(self.value)))
+
+    def jump_to_click(self, event):
+        self.activate_knob(event)
+
+    def update_slider_from_entry(self, event):
+        """Update the slider's value from the entry."""
+        try:
+            index = int(self.index_var.get())
+            self.set(index)
+            if self.command:
+                self.command(self.value)
+        except ValueError:
+            pass
+
+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
-        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'])
-        self.canvas.grid(row=0, column=0, sticky="ew")
+        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
+
+        self.style_out = set_dark_style(ttk.Style())
+        self.font_style = self.style_out['font_family']
+        self.font_size = self.style_out['font_size']
+        self.font_family = self.style_out['font_family']
+        self.font_loader = self.style_out['font_loader']
 
-        self.font_style = font if font else tkFont.Font(family=style_out['font_family'], size=style_out['font_size'], weight=tkFont.NORMAL)
+        self.canvas = tk.Canvas(self, width=label_width, height=label_height, highlightthickness=0, bg=self.style_out['bg_color'])
+        self.canvas.grid(row=0, column=0, sticky="ew")
+        if self.style_out['font_family'] != 'OpenSans':
+            self.font_style = font if font else tkFont.Font(family=self.style_out['font_family'], size=self.style_out['font_size'], weight=tkFont.NORMAL)
         self.style = style
 
         if self.align == "center":
@@ -467,13 +988,21 @@ class spacrLabel(tk.Frame):
 
         if self.style:
             ttk_style = ttk.Style()
-            ttk_style.configure(self.style, font=self.font_style, background=style_out['bg_color'], foreground=style_out['fg_color'])
+            if self.font_loader:
+                ttk_style.configure(self.style, font=self.font_loader.get_font(size=self.font_size), background=self.style_out['bg_color'], foreground=self.style_out['fg_color'])
+            else:
+                ttk_style.configure(self.style, font=self.font_style, background=self.style_out['bg_color'], foreground=self.style_out['fg_color'])
             self.label_text = ttk.Label(self.canvas, text=self.text, style=self.style, anchor=text_anchor)
             self.label_text.pack(fill=tk.BOTH, expand=True)
         else:
-            self.label_text = self.canvas.create_text(label_width // 2 if self.align == "center" else label_width - 5, 
-                                                      label_height // 2, text=self.text, fill=style_out['fg_color'], 
-                                                      font=self.font_style, anchor=anchor_value, justify=tk.RIGHT)
+            if self.font_loader:
+                self.label_text = self.canvas.create_text(label_width // 2 if self.align == "center" else label_width - 5, 
+                                                          label_height // 2, text=self.text, fill=self.style_out['fg_color'], 
+                                                          font=self.font_loader.get_font(size=self.font_size), anchor=anchor_value, justify=tk.RIGHT)
+            else:
+                self.label_text = self.canvas.create_text(label_width // 2 if self.align == "center" else label_width - 5, 
+                                                        label_height // 2, text=self.text, fill=self.style_out['fg_color'], 
+                                                        font=self.font_style, anchor=anchor_value, justify=tk.RIGHT)
         
         _ = set_dark_style(ttk.Style(), containers=[self], widgets=[self.canvas])
 
@@ -484,7 +1013,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,8 +1022,11 @@ 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())
+        self.font_size = style_out['font_size']
+        self.font_loader = style_out['font_loader']
 
         if self.show_text:
             self.button_width = int(size * 3)
@@ -516,7 +1048,10 @@ class spacrButton(tk.Frame):
             self.button_bg = self.create_rounded_rectangle(2, 2, self.button_width + 2, self.size + 2, radius=20, fill=self.inactive_color, outline=self.inactive_color)
         
         self.load_icon()
-        self.font_style = font if font else ("Arial", 12)  # Default font if not provided
+        if self.font_loader:
+            self.font_style = self.font_loader.get_font(size=self.font_size)
+        else:
+            self.font_style = font if font else ("Arial", 12)
         
         if self.show_text:
             self.button_text = self.canvas.create_text(self.size + 10, self.size // 2 + 2, text=self.text, fill=color_settings['fg_color'], font=self.font_style, anchor="w")  # Align text to the left of the specified point
@@ -559,13 +1094,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):
@@ -1614,6 +2149,19 @@ class AnnotateApp:
         self.threshold = threshold
 
         style_out = set_dark_style(ttk.Style())
+        self.font_loader = style_out['font_loader']
+        self.font_size = style_out['font_size']
+        self.bg_color = style_out['bg_color']
+        self.fg_color = style_out['fg_color']
+        self.active_color = style_out['active_color']
+        self.inactive_color = style_out['inactive_color']
+
+
+        if self.font_loader:
+            self.font_style = self.font_loader.get_font(size=self.font_size)
+        else:
+            self.font_style = ("Arial", 12)
+        
         self.root.configure(bg=style_out['inactive_color'])
 
         self.filtered_paths_annotations = []
@@ -1627,20 +2175,20 @@ class AnnotateApp:
         self.root.update_idletasks()
 
         # Create the status label
-        self.status_label = Label(root, text="", font=("Arial", 12), bg=self.root.cget('bg'))
+        self.status_label = Label(root, text="", font=self.font_style, bg=self.root.cget('bg'))
         self.status_label.grid(row=2, column=0, padx=10, pady=10, sticky="w")
 
         # Place the buttons at the bottom right
         self.button_frame = Frame(root, bg=self.root.cget('bg'))
         self.button_frame.grid(row=2, column=1, padx=10, pady=10, sticky="se")
 
-        self.next_button = Button(self.button_frame, text="Next", command=self.next_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.next_button = Button(self.button_frame, text="Next", command=self.next_page, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.next_button.pack(side="right", padx=5)
 
-        self.previous_button = Button(self.button_frame, text="Back", command=self.previous_page, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.previous_button = Button(self.button_frame, text="Back", command=self.previous_page, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.previous_button.pack(side="right", padx=5)
 
-        self.exit_button = Button(self.button_frame, text="Exit", command=self.shutdown, bg='black', fg='white', highlightbackground='white', highlightcolor='white', highlightthickness=1)
+        self.exit_button = Button(self.button_frame, text="Exit", command=self.shutdown, bg=self.bg_color, fg=self.fg_color, highlightbackground=self.fg_color, highlightcolor=self.fg_color, highlightthickness=1)
         self.exit_button.pack(side="right", padx=5)
 
         # Calculate grid rows and columns based on the root window size and image size
@@ -1704,6 +2252,7 @@ class AnnotateApp:
                                 print(f"median threshold measurement: {np.median(df[self.measurement])}")
                                 df = df[df[f'threshold_measurement_{idx}'] > thd]
                         after = len(df)
+            
             elif isinstance(self.measurement, list):
                 df['threshold_measurement'] = df[self.measurement[0]]/df[self.measurement[1]]
                 print(f"mean threshold measurement: {np.mean(df['threshold_measurement'])}")
@@ -1712,6 +2261,7 @@ class AnnotateApp:
                 after = len(df)
                 self.measurement = 'threshold_measurement'
                 print(f'Removed: {before-after} rows, retained {after}')
+            
             else:
                 print(f"mean threshold measurement: {np.mean(df[self.measurement])}")
                 print(f"median threshold measurement: {np.median(df[self.measurement])}")
@@ -1788,7 +2338,7 @@ class AnnotateApp:
 
         for i, (img, annotation) in enumerate(loaded_images):
             if annotation:
-                border_color = 'teal' if annotation == 1 else 'red'
+                border_color = self.active_color if annotation == 1 else 'red'
                 img = self.add_colored_border(img, border_width=5, border_color=border_color)
 
             photo = ImageTk.PhotoImage(img)
@@ -1834,7 +2384,7 @@ class AnnotateApp:
         left_border = Image.new('RGB', (border_width, img.height), color=border_color)
         right_border = Image.new('RGB', (border_width, img.height), color=border_color)
 
-        bordered_img = Image.new('RGB', (img.width + 2 * border_width, img.height + 2 * border_width), color='white')
+        bordered_img = Image.new('RGB', (img.width + 2 * border_width, img.height + 2 * border_width), color=self.fg_color)
         bordered_img.paste(top_border, (border_width, 0))
         bordered_img.paste(bottom_border, (border_width, img.height + border_width))
         bordered_img.paste(left_border, (0, border_width))
@@ -1874,7 +2424,7 @@ class AnnotateApp:
             print(f"Image {os.path.split(path)[1]} annotated: {new_annotation}")
             
             img_ = img.crop((5, 5, img.width-5, img.height-5))
-            border_fill = 'teal' if new_annotation == 1 else ('red' if new_annotation == 2 else None)
+            border_fill = self.active_color if new_annotation == 1 else ('red' if new_annotation == 2 else None)
             img_ = ImageOps.expand(img_, border=5, fill=border_fill) if border_fill else img_
 
             photo = ImageTk.PhotoImage(img_)
@@ -1957,25 +2507,22 @@ class AnnotateApp:
 def create_menu_bar(root):
     from .gui import initiate_root
     gui_apps = {
-        "Mask": (lambda frame: initiate_root(frame, settings_type='mask'), "Generate cellpose masks for cells, nuclei and pathogen images."),
-        "Measure": (lambda frame: initiate_root(frame, settings_type='measure'), "Measure single object intensity and morphological feature. Crop and save single object image"),
-        "Annotate": (lambda frame: initiate_root(frame, settings_type='annotate'), "Annotation single object images on a grid. Annotations are saved to database."),
-        "Make Masks": (lambda frame: initiate_root(frame, settings_type='make_masks'), "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
-        "Classify": (lambda frame: initiate_root(frame, settings_type='classify'), "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images."),
-        "Sequencing": (lambda frame: initiate_root(frame, settings_type='sequencing'), "Analyze sequencing data."),
-        "Umap": (lambda frame: initiate_root(frame, settings_type='umap'), "Generate UMAP embeddings with datapoints represented as images."),
-        "Train Cellpose": (lambda frame: initiate_root(frame, settings_type='train_cellpose'), "Train custom Cellpose models."),
-        "ML Analyze": (lambda frame: initiate_root(frame, settings_type='ml_analyze'), "Machine learning analysis of data."),
-        "Cellpose Masks": (lambda frame: initiate_root(frame, settings_type='cellpose_masks'), "Generate Cellpose masks."),
-        "Cellpose All": (lambda frame: initiate_root(frame, settings_type='cellpose_all'), "Run Cellpose on all images."),
-        "Map Barcodes": (lambda frame: initiate_root(frame, settings_type='map_barcodes'), "Map barcodes to data."),
-        "Regression": (lambda frame: initiate_root(frame, settings_type='regression'), "Perform regression analysis."),
-        "Recruitment": (lambda frame: initiate_root(frame, settings_type='recruitment'), "Analyze recruitment data.")
+        "Mask": lambda: initiate_root(root, settings_type='mask'),
+        "Measure": lambda: initiate_root(root, settings_type='measure'),
+        "Annotate": lambda: initiate_root(root, settings_type='annotate'),
+        "Make Masks": lambda: initiate_root(root, settings_type='make_masks'),
+        "Classify": lambda: initiate_root(root, settings_type='classify'),
+        "Sequencing": lambda: initiate_root(root, settings_type='sequencing'),
+        "Umap": lambda: initiate_root(root, settings_type='umap'),
+        "Train Cellpose": lambda: initiate_root(root, settings_type='train_cellpose'),
+        "ML Analyze": lambda: initiate_root(root, settings_type='ml_analyze'),
+        "Cellpose Masks": lambda: initiate_root(root, settings_type='cellpose_masks'),
+        "Cellpose All": lambda: initiate_root(root, settings_type='cellpose_all'),
+        "Map Barcodes": lambda: initiate_root(root, settings_type='map_barcodes'),
+        "Regression": lambda: initiate_root(root, settings_type='regression'),
+        "Recruitment": lambda: initiate_root(root, settings_type='recruitment')
     }
 
-    def load_app_wrapper(app_name, app_func):
-        root.load_app(app_name, app_func)
-
     # Create the menu bar
     menu_bar = tk.Menu(root, bg="#008080", fg="white")
 
@@ -1984,13 +2531,315 @@ def create_menu_bar(root):
     menu_bar.add_cascade(label="SpaCr Applications", menu=app_menu)
 
     # Add options to the "SpaCr Applications" menu
-    for app_name, app_data in gui_apps.items():
-        app_func, app_desc = app_data
-        app_menu.add_command(label=app_name, command=lambda app_name=app_name, app_func=app_func: load_app_wrapper(app_name, app_func))
+    for app_name, app_func in gui_apps.items():
+        app_menu.add_command(
+            label=app_name,
+            command=app_func
+        )
 
     # Add a separator and an exit option
     app_menu.add_separator()
+    app_menu.add_command(label="Help", command=lambda: webbrowser.open("https://spacr.readthedocs.io/en/latest/?badge=latest"))
     app_menu.add_command(label="Exit", command=root.quit)
 
     # Configure the menu for the root window
     root.config(menu=menu_bar)
+
+def standardize_figure(fig):
+    from .gui_elements import set_dark_style
+    from matplotlib.font_manager import FontProperties
+
+    style_out = set_dark_style(ttk.Style())
+    bg_color = style_out['bg_color']
+    fg_color = style_out['fg_color']
+    font_size = style_out['font_size']
+    font_loader = style_out['font_loader']
+
+    # Get the custom font path from the font loader
+    font_path = font_loader.font_path
+    font_prop = FontProperties(fname=font_path, size=font_size)
+
+    """
+    Standardizes the appearance of the figure:
+    - Font size: from style
+    - Font color: from style
+    - Font family: custom OpenSans from font_loader
+    - Removes top and right spines
+    - Figure and subplot background: from style
+    - Line width: 1
+    - Line color: from style
+    """
+    
+
+    for ax in fig.get_axes():
+        # Set font properties for title and labels
+        ax.title.set_fontsize(font_size)
+        ax.title.set_color(fg_color)
+        ax.title.set_fontproperties(font_prop)
+
+        ax.xaxis.label.set_fontsize(font_size)
+        ax.xaxis.label.set_color(fg_color)
+        ax.xaxis.label.set_fontproperties(font_prop)
+
+        ax.yaxis.label.set_fontsize(font_size)
+        ax.yaxis.label.set_color(fg_color)
+        ax.yaxis.label.set_fontproperties(font_prop)
+
+        # Set font properties for tick labels
+        for label in ax.get_xticklabels() + ax.get_yticklabels():
+            label.set_fontsize(font_size)
+            label.set_color(fg_color)
+            label.set_fontproperties(font_prop)
+
+        # Remove top and right spines
+        ax.spines['top'].set_visible(False)
+        ax.spines['right'].set_visible(False)
+        ax.spines['left'].set_visible(True)
+        ax.spines['bottom'].set_visible(True)
+
+        # Set spine line width and color
+        for spine in ax.spines.values():
+            spine.set_linewidth(1)
+            spine.set_edgecolor(fg_color)
+
+        # Set line width and color
+        for line in ax.get_lines():
+            line.set_linewidth(1)
+            line.set_color(fg_color)
+
+        # Set subplot background color
+        ax.set_facecolor(bg_color)
+
+        # Adjust the grid if needed
+        ax.grid(True, color='gray', linestyle='--', linewidth=0.5)
+
+    # Set figure background color
+    fig.patch.set_facecolor(bg_color)
+
+    fig.canvas.draw_idle()
+
+    return fig
+
+def modify_figure_properties(fig, scale_x=None, scale_y=None, line_width=None, font_size=None, x_lim=None, y_lim=None, grid=False, legend=None, title=None, x_label_rotation=None, remove_axes=False, bg_color=None, text_color=None, line_color=None):
+    """
+    Modifies the properties of the figure, including scaling, line widths, font sizes, axis limits, x-axis label rotation, background color, text color, line color, and other common options.
+
+    Parameters:
+    - fig: The Matplotlib figure object to modify.
+    - scale_x: Scaling factor for the width of subplots (optional).
+    - scale_y: Scaling factor for the height of subplots (optional).
+    - line_width: Desired line width for all lines (optional).
+    - font_size: Desired font size for all text (optional).
+    - x_lim: Tuple specifying the x-axis limits (min, max) (optional).
+    - y_lim: Tuple specifying the y-axis limits (min, max) (optional).
+    - grid: Boolean to add grid lines to the plot (optional).
+    - legend: Boolean to show/hide the legend (optional).
+    - title: String to set as the title of the plot (optional).
+    - x_label_rotation: Angle to rotate the x-axis labels (optional).
+    - remove_axes: Boolean to remove or show the axes labels (optional).
+    - bg_color: Color for the figure and subplot background (optional).
+    - text_color: Color for all text in the figure (optional).
+    - line_color: Color for all lines in the figure (optional).
+    """
+    if fig is None:
+        print("Error: The figure provided is None.")
+        return
+
+    for ax in fig.get_axes():
+        # Rescale subplots if scaling factors are provided
+        if scale_x is not None or scale_y is not None:
+            bbox = ax.get_position()
+            width = bbox.width * (scale_x if scale_x else 1)
+            height = bbox.height * (scale_y if scale_y else 1)
+            new_bbox = [bbox.x0, bbox.y0, width, height]
+            ax.set_position(new_bbox)
+
+        # Set axis limits if provided
+        if x_lim is not None:
+            ax.set_xlim(x_lim)
+        if y_lim is not None:
+            ax.set_ylim(y_lim)
+
+        # Set grid visibility only
+        ax.grid(grid)
+
+        # Adjust line width and color if specified
+        if line_width is not None or line_color is not None:
+            for line in ax.get_lines():
+                if line_width is not None:
+                    line.set_linewidth(line_width)
+                if line_color is not None:
+                    line.set_color(line_color)
+            for spine in ax.spines.values():  # Modify width and color of spines (e.g., scale bars)
+                if line_width is not None:
+                    spine.set_linewidth(line_width)
+                if line_color is not None:
+                    spine.set_edgecolor(line_color)
+            ax.tick_params(width=line_width, colors=text_color if text_color else 'black')
+
+        # Adjust font size if specified
+        if font_size is not None:
+            for label in ax.get_xticklabels() + ax.get_yticklabels():
+                label.set_fontsize(font_size)
+            ax.title.set_fontsize(font_size)
+            ax.xaxis.label.set_fontsize(font_size)
+            ax.yaxis.label.set_fontsize(font_size)
+            if ax.legend_:
+                for text in ax.legend_.get_texts():
+                    text.set_fontsize(font_size)
+
+        # Rotate x-axis labels if rotation is specified
+        if x_label_rotation is not None:
+            for label in ax.get_xticklabels():
+                label.set_rotation(x_label_rotation)
+                if 0 <= x_label_rotation <= 90:
+                    label.set_ha('center')
+
+        # Toggle axes labels visibility without affecting the grid or spines
+        if remove_axes:
+            ax.xaxis.set_visible(False)
+            ax.yaxis.set_visible(False)
+        else:
+            ax.xaxis.set_visible(True)
+            ax.yaxis.set_visible(True)
+
+        # Set text color if specified
+        if text_color:
+            ax.title.set_color(text_color)
+            ax.xaxis.label.set_color(text_color)
+            ax.yaxis.label.set_color(text_color)
+            ax.tick_params(colors=text_color)
+            for label in ax.get_xticklabels() + ax.get_yticklabels():
+                label.set_color(text_color)
+
+        # Set background color for subplots if specified
+        if bg_color:
+            ax.set_facecolor(bg_color)
+
+    # Set figure background color if specified
+    if bg_color:
+        fig.patch.set_facecolor(bg_color)
+
+    fig.canvas.draw_idle()
+
+def save_figure_as_format(fig, file_format):
+    file_path = filedialog.asksaveasfilename(defaultextension=f".{file_format}", filetypes=[(f"{file_format.upper()} files", f"*.{file_format}"), ("All files", "*.*")])
+    if file_path:
+        try:
+            fig.savefig(file_path, format=file_format)
+            print(f"Figure saved as {file_format.upper()} at {file_path}")
+        except Exception as e:
+            print(f"Error saving figure: {e}")
+
+def modify_figure(fig):
+    from .gui_core import display_figure
+    def apply_modifications():
+        try:
+            # Only apply changes if the fields are filled
+            scale_x = float(scale_x_var.get()) if scale_x_var.get() else None
+            scale_y = float(scale_y_var.get()) if scale_y_var.get() else None
+            line_width = float(line_width_var.get()) if line_width_var.get() else None
+            font_size = int(font_size_var.get()) if font_size_var.get() else None
+            x_lim = eval(x_lim_var.get()) if x_lim_var.get() else None
+            y_lim = eval(y_lim_var.get()) if y_lim_var.get() else None
+            title = title_var.get() if title_var.get() else None
+            bg_color = bg_color_var.get() if bg_color_var.get() else None
+            text_color = text_color_var.get() if text_color_var.get() else None
+            line_color = line_color_var.get() if line_color_var.get() else None
+            x_label_rotation = int(x_label_rotation_var.get()) if x_label_rotation_var.get() else None
+
+            modify_figure_properties(
+                fig,
+                scale_x=scale_x,
+                scale_y=scale_y,
+                line_width=line_width,
+                font_size=font_size,
+                x_lim=x_lim,
+                y_lim=y_lim,
+                grid=grid_var.get(),
+                legend=legend_var.get(),
+                title=title,
+                x_label_rotation=x_label_rotation,
+                remove_axes=remove_axes_var.get(),
+                bg_color=bg_color,
+                text_color=text_color,
+                line_color=line_color
+            )
+            display_figure(fig)
+        except ValueError:
+            print("Invalid input; please enter numeric values.")
+
+    def toggle_spleens():
+        for ax in fig.get_axes():
+            if spleens_var.get():
+                ax.spines['top'].set_visible(False)
+                ax.spines['right'].set_visible(False)
+                ax.spines['left'].set_visible(True)
+                ax.spines['bottom'].set_visible(True)
+                ax.spines['top'].set_linewidth(2)
+                ax.spines['right'].set_linewidth(2)
+            else:
+                ax.spines['top'].set_visible(True)
+                ax.spines['right'].set_visible(True)
+            display_figure(fig)
+
+    # Create a new window for user input
+    modify_window = tk.Toplevel()
+    modify_window.title("Modify Figure Properties")
+
+    # Apply dark style to the popup window
+    style = ttk.Style()
+    style.configure("TCheckbutton", background="#2E2E2E", foreground="white", selectcolor="blue")
+
+    modify_window.configure(bg="#2E2E2E")
+
+    # Create and style the input fields
+    scale_x_var = tk.StringVar()
+    scale_y_var = tk.StringVar()
+    line_width_var = tk.StringVar()
+    font_size_var = tk.StringVar()
+    x_lim_var = tk.StringVar()
+    y_lim_var = tk.StringVar()
+    title_var = tk.StringVar()
+    bg_color_var = tk.StringVar()
+    text_color_var = tk.StringVar()
+    line_color_var = tk.StringVar()
+    x_label_rotation_var = tk.StringVar()
+    remove_axes_var = tk.BooleanVar()
+    grid_var = tk.BooleanVar()
+    legend_var = tk.BooleanVar()
+    spleens_var = tk.BooleanVar()
+
+    options = [
+        ("Rescale X:", scale_x_var),
+        ("Rescale Y:", scale_y_var),
+        ("Line Width:", line_width_var),
+        ("Font Size:", font_size_var),
+        ("X Axis Limits (tuple):", x_lim_var),
+        ("Y Axis Limits (tuple):", y_lim_var),
+        ("Title:", title_var),
+        ("X Label Rotation (degrees):", x_label_rotation_var),
+        ("Background Color:", bg_color_var),
+        ("Text Color:", text_color_var),
+        ("Line Color:", line_color_var)
+    ]
+
+    for i, (label_text, var) in enumerate(options):
+        tk.Label(modify_window, text=label_text, bg="#2E2E2E", fg="white").grid(row=i, column=0, padx=10, pady=5)
+        tk.Entry(modify_window, textvariable=var, bg="#2E2E2E", fg="white").grid(row=i, column=1, padx=10, pady=5)
+
+    checkboxes = [
+        ("Grid", grid_var),
+        ("Legend", legend_var),
+        ("Spleens", spleens_var),
+        ("Remove Axes", remove_axes_var)
+    ]
+
+    for i, (label_text, var) in enumerate(checkboxes, start=len(options)):
+        ttk.Checkbutton(modify_window, text=label_text, variable=var, style="TCheckbutton").grid(row=i, column=0, padx=10, pady=5, columnspan=2, sticky='w')
+
+    spleens_var.trace_add("write", lambda *args: toggle_spleens())
+
+    # Apply button
+    apply_button = tk.Button(modify_window, text="Apply", command=apply_modifications, bg="#2E2E2E", fg="white")
+    apply_button.grid(row=len(options) + len(checkboxes), column=0, columnspan=2, pady=10)