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

spacr/gui_elements.py

@@ -1,9 +1,9 @@
-import os, threading, time, sqlite3
+import os, threading, time, sqlite3, webbrowser
 import tkinter as tk
 from tkinter import ttk
 import tkinter.font as tkFont
 from queue import Queue
-from tkinter import Label
+from tkinter import Label, Frame, Button
 import numpy as np
 from PIL import Image, ImageOps, ImageTk
 from concurrent.futures import ThreadPoolExecutor
@@ -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,14 +523,16 @@ 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.inactive_color = style_out['inactive_color']
+
+        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 style for the progress bar
         self.style = ttk.Style()
@@ -387,44 +549,155 @@ class spacrProgressBar(ttk.Progressbar):
         # Set initial value to 0
         self['value'] = 0
 
+        # 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
+        self.time_image = None
+        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):
+        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'])
@@ -459,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
@@ -468,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())
 
@@ -534,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):
@@ -1561,14 +1835,19 @@ class ModifyMaskApp:
         self.update_display()
 
 class AnnotateApp:
-    def __init__(self, root, db_path, src, image_type=None, channels=None, grid_rows=None, grid_cols=None, image_size=(200, 200), annotation_column='annotate', normalize=False, percentiles=(1,99), measurement=None, threshold=None):
+    def __init__(self, root, db_path, src, image_type=None, channels=None, image_size=200, annotation_column='annotate', normalize=False, percentiles=(1, 99), measurement=None, threshold=None):
         self.root = root
         self.db_path = db_path
         self.src = src
         self.index = 0
-        self.grid_rows = grid_rows
-        self.grid_cols = grid_cols
-        self.image_size = image_size
+
+        if isinstance(image_size, list):
+            self.image_size = (int(image_size[0]), int(image_size[0]))
+        elif isinstance(image_size, int):
+            self.image_size = (image_size, image_size)
+        else:
+            raise ValueError("Invalid image size")
+
         self.annotation_column = annotation_column
         self.image_type = image_type
         self.channels = channels
@@ -1580,22 +1859,72 @@ class AnnotateApp:
         self.adjusted_to_original_paths = {}
         self.terminate = False
         self.update_queue = Queue()
-        self.status_label = Label(self.root, text="", font=("Arial", 12))
-        self.status_label.grid(row=self.grid_rows + 1, column=0, columnspan=self.grid_cols)
         self.measurement = measurement
         self.threshold = threshold
 
+        style_out = set_dark_style(ttk.Style())
+        self.root.configure(bg=style_out['inactive_color'])
+
         self.filtered_paths_annotations = []
         self.prefilter_paths_annotations()
 
         self.db_update_thread = threading.Thread(target=self.update_database_worker)
         self.db_update_thread.start()
 
-        for i in range(grid_rows * grid_cols):
-            label = Label(root)
-            label.grid(row=i // grid_cols, column=i % grid_cols)
+        # Set the initial window size and make it fit the screen size
+        self.root.geometry(f"{self.root.winfo_screenwidth()}x{self.root.winfo_screenheight()}")
+        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.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.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.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.pack(side="right", padx=5)
+
+        # Calculate grid rows and columns based on the root window size and image size
+        self.calculate_grid_dimensions()
+
+        # Create a frame to hold the image grid
+        self.grid_frame = Frame(root, bg=self.root.cget('bg'))
+        self.grid_frame.grid(row=0, column=0, columnspan=2, padx=0, pady=0, sticky="nsew")
+
+        for i in range(self.grid_rows * self.grid_cols):
+            label = Label(self.grid_frame, bg=self.root.cget('bg'))
+            label.grid(row=i // self.grid_cols, column=i % self.grid_cols, padx=2, pady=2, sticky="nsew")
             self.labels.append(label)
 
+        # Make the grid frame resize with the window
+        self.root.grid_rowconfigure(0, weight=1)
+        self.root.grid_columnconfigure(0, weight=1)
+        self.root.grid_columnconfigure(1, weight=1)
+
+        for row in range(self.grid_rows):
+            self.grid_frame.grid_rowconfigure(row, weight=1)
+        for col in range(self.grid_cols):
+            self.grid_frame.grid_columnconfigure(col, weight=1)
+
+    def calculate_grid_dimensions(self):
+        window_width = self.root.winfo_width()
+        window_height = self.root.winfo_height()
+
+        self.grid_cols = window_width // (self.image_size[0] + 4)
+        self.grid_rows = (window_height - self.button_frame.winfo_height() - 4) // (self.image_size[1] + 4)
+
+        # Update to make sure grid_rows and grid_cols are at least 1
+        self.grid_cols = max(1, self.grid_cols)
+        self.grid_rows = max(1, self.grid_rows)
+
     def prefilter_paths_annotations(self):
         from .io import _read_and_join_tables
         from .utils import is_list_of_lists
@@ -1849,6 +2178,7 @@ class AnnotateApp:
             self.update_queue.put(self.pending_updates.copy())
         self.pending_updates.clear()
         self.index += self.grid_rows * self.grid_cols
+        self.prefilter_paths_annotations()  # Re-fetch annotations from the database
         self.load_images()
 
     def previous_page(self):
@@ -1858,16 +2188,20 @@ class AnnotateApp:
         self.index -= self.grid_rows * self.grid_cols
         if self.index < 0:
             self.index = 0
+        self.prefilter_paths_annotations()  # Re-fetch annotations from the database
         self.load_images()
 
     def shutdown(self):
         self.terminate = True
         self.update_queue.put(self.pending_updates.copy())
-        self.pending_updates.clear()
-        self.db_update_thread.join()
-        self.root.quit()
-        self.root.destroy()
-        print(f'Quit application')
+        if not self.pending_updates:
+            self.pending_updates.clear()
+            self.db_update_thread.join()
+            self.root.quit()
+            self.root.destroy()
+            print(f'Quit application')
+        else:
+            print('Waiting for pending updates to finish before quitting')
 
 def create_menu_bar(root):
     from .gui import initiate_root
@@ -1905,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