Added auto-break

Author: simon-milata

Package/data_management.py

@@ -239,10 +239,35 @@ def save_weekday_data(self) -> None:
         self.worksheet["W8"].value = self.sunday_duration
 
 
-    def save_autobreak(self, frequency: str, duration: str) -> None:
-        frequency = int(frequency)
-        duration = int(duration)
-        print(frequency, duration)
+    def save_autobreak(self, frequency: str, duration: str, switch: str) -> None:
+        self.worksheet["P2"].value = switch
+        self.worksheet["P3"].value = int(frequency)
+        self.worksheet["P4"].value = int(duration)
+
+        self.workbook.save(self.app.data_file)
+
+        self.load_autobreak()
+        
+
+    def load_autobreak(self):
+        self.autobreak_on = self.worksheet["P2"].value
+        self.autobreak_frequency = self.worksheet["P3"].value
+        self.autobreak_duration = self.worksheet["P4"].value
+
+        if self.worksheet["P2"].value == None:
+            self.autobreak_on = "Off"
+
+        if self.autobreak_frequency == None:
+            self.autobreak_frequency = 25
+
+        if self.autobreak_duration == None:
+            self.autobreak_duration = 5
+
+        self.app.frequency_input.configure(placeholder_text=self.autobreak_frequency)
+        self.app.duration_input.configure(placeholder_text=self.autobreak_duration)
+        self.app.autobreak_switch.configure(variable=ctk.StringVar(value=self.autobreak_on))
+
+        self.app.WINDOW.after(0, self.app.auto_break)
 
 
     def set_color(self, color_dropdown) -> None:
@@ -382,4 +407,4 @@ def load_eye_care(self) -> None:
 
         self.app.eye_care_checkbox.configure(variable=ctk.StringVar(value=checkbox))
 
-        self.app.t1.start()
+        self.app.WINDOW.after(0, self.app.eye_protection)  # Schedule initial iteration for eye_protection

Package/timer_management.py

@@ -17,6 +17,12 @@ def initialize_variables(self):
     def timer_mechanism(self, timer_button, break_button, time_display_label):
         self.time_display_label = time_display_label
         if not self.timer_running:
+            self.app.frequency_input.configure(state="disabled")
+            self.app.frequency_input.insert("end", self.app.data_manager.autobreak_frequency)
+            self.app.duration_input.configure(state="disabled")
+            self.app.duration_input.insert("end", self.app.data_manager.autobreak_duration)
+            self.app.autobreak_button.configure(state="readonly")
+
             self.timer_running = True
             self.break_running = False
             timer_button.configure(text="Stop")
@@ -32,6 +38,7 @@ def _update_time(self):
         if self.timer_running:
             self.timer_time += 1
             self.time_display_label.configure(text=str(datetime.timedelta(seconds=self.timer_time)))
+            self.app.progressbar.set(self.timer_time/60/self.app.goal)
             self.app.reach_goal(self.timer_time)
             self.window.after(1000, self._update_time)
 

main.py

@@ -1,7 +1,5 @@
 import os
 import random
-import time
-import threading
 from PIL import Image
 
 import openpyxl as op
@@ -29,11 +27,9 @@ def __init__(self):
         self.create_gui()
         self._file_setup()
 
-        self.t1 = threading.Thread(target=self.eye_protection)
-        self.stop_event = threading.Event()
-
         self.data_manager.load_subject()
         self.data_manager.load_eye_care()
+        self.data_manager.load_autobreak()
 
         self.WINDOW.bind_all("<Button>", self.change_focus)
         self.WINDOW.protocol("WM_DELETE_WINDOW", self.save_on_quit)
@@ -172,7 +168,7 @@ def _initialize_tab(tab_name: str, icon: ctk.CTkImage) -> None:
 
             #Place settings tab frame on the bottom of tab frame
             if tab_name == "Settings":
-                tab.place(relx=0.5, rely=1, anchor="s")
+                tab.place(relx=0.5, rely=0.995, anchor="s")
             else:
                 tab.pack(pady=tab_padding_y)
             tab_button.place(relx=0.5, rely=0.5, anchor="center")
@@ -456,9 +452,9 @@ def _autobreak_gui_setup(self) -> None:
                                                 font=(font_family, int(font_size)), fg_color=(light_border_frame_color, border_frame_color), button_color=(light_border_frame_color, border_frame_color), border_color=(light_border_frame_color, border_frame_color))
         self.autobreak_switch.pack()
 
-        autobreak_button = ctk.CTkButton(autobreak_frame, text="Save", font=(font_family, font_size), fg_color=button_color, text_color=button_font_color,
+        self.autobreak_button = ctk.CTkButton(autobreak_frame, text="Save", font=(font_family, font_size), fg_color=button_color, text_color=button_font_color,
                                         border_color=frame_border_color, hover_color=button_highlight_color, height=button_height, command=self.save_autobreak)
-        autobreak_button.place(anchor="s", relx=0.5, rely=0.925)
+        self.autobreak_button.place(anchor="s", relx=0.5, rely=0.925)
 
 
     def _notes_gui_setup(self) -> None:
@@ -531,7 +527,7 @@ def _format_func(value, tick_number):
         ax.xaxis.set_major_formatter(date_format)
         ax.xaxis.set_major_locator(MaxNLocator(integer=True, prune='both'))
         time_spent_frame = FigureCanvasTkAgg(fig, master=frame)
-        plt.subplots_adjust(bottom=0.2)
+        plt.subplots_adjust(bottom=0.15)
 
         time_spent_graph = time_spent_frame.get_tk_widget()
         time_spent_graph.pack(padx=widget_padding_x, pady=widget_padding_y)
@@ -557,7 +553,7 @@ def _my_format(pct):
 
         fig, ax = plt.subplots()
         ax.pie(non_zero_durations, labels=non_zero_names, autopct=_autopct_format(non_zero_durations), colors=self.data_manager.pie_colors, 
-               textprops={"fontsize": pie_font_size, "family": pie_font_family, "color": font_color}, counterclock=False, startangle=90)
+               textprops={"fontsize": pie_font_size, "family": pie_font_family, "color": self.data_manager.font_color}, counterclock=False, startangle=90)
         fig.set_size_inches(graph_width/100, graph_height/100, forward=True)
         ax.set_facecolor(self.data_manager.graph_fg_color)
         fig.set_facecolor(self.data_manager.graph_bg_color)
@@ -567,6 +563,7 @@ def _my_format(pct):
         ax.spines["bottom"].set_color(self.data_manager.spine_color)
         ax.spines["left"].set_color(self.data_manager.spine_color)
         ax.spines["right"].set_color(self.data_manager.spine_color)
+        plt.subplots_adjust(bottom=0.0)
 
         weekday_frame = FigureCanvasTkAgg(fig, master=frame)
 
@@ -719,6 +716,12 @@ def save_data(self) -> None:
 
         #Only be able to save if time is higher than 1m
         if time_in_minutes >= 1:
+            self.frequency_input.configure(state="normal")
+            self.frequency_input.delete("end")
+            self.duration_input.configure(state="normal")
+            self.duration_input.delete("end")
+            self.autobreak_button.configure(state="normal")
+
             if time_in_minutes >= self.goal:
                 self.data_manager.increase_goal_streak()
 
@@ -739,40 +742,72 @@ def save_data(self) -> None:
     def save_autobreak(self) -> None:
         frequency_input = self.frequency_input.get()[:2]
         if len(frequency_input) == 0:
-            frequency_input = "30"
-        elif not frequency_input.isdigit():
-            return
+            frequency_input = self.data_manager.autobreak_frequency
+        else:
+            if self.data_manager.autobreak_frequency != self.frequency_input.cget("placeholder_text"):
+                if len(frequency_input) == 0 or int(frequency_input) < 1:
+                    frequency_input = "25"
+                elif not frequency_input.isdigit():
+                    return
 
         duration_input = self.duration_input.get()[:2]
         if len(duration_input) == 0:
-            duration_input = "30"
-        elif not duration_input.isdigit():
-            return
+            duration_input = self.data_manager.autobreak_duration
+        else:
+            if self.data_manager.autobreak_duration != self.duration_input.cget("placeholder_text"):
+                if len(duration_input) == 0 or int(duration_input) < 1:
+                    duration_input = "5"
+                elif not duration_input.isdigit():
+                    return
+            
 
-        self.frequency_input.delete("2", "end")
-        self.duration_input.delete("2", "end")
+        self.frequency_input.delete("0", "end")
+        self.duration_input.delete("0", "end")
+        self.frequency_input.insert("0", frequency_input)
+        self.duration_input.insert("0", duration_input)
+
+        if self.autobreak_switch.get() == "On":
+            switch = "On"
+        else:
+            switch = "Off"
 
-        self.data_manager.save_autobreak(frequency_input, duration_input)
+        print(frequency_input, duration_input)
+        self.data_manager.save_autobreak(frequency_input, duration_input, switch)
 
 
     def eye_protection(self):
         checkbox = self.eye_care_checkbox.get()
         time_between = 60 * 20
-        while not self.stop_event.is_set():
-            if self.eye_care_selection.get() == "On":
-                if checkbox == "On" and self.timer_manager.timer_running:
-                    time.sleep(time_between)
-                    if checkbox == "On" and self.timer_manager.timer_running:
-                        self.send_notification("Eye Protection", "Look away 20ft for 20 seconds")
-                        self.eye_protection()
-                else:
-                    time.sleep(time_between)
-                    if self.eye_care_selection.get() == "On" and checkbox == "Off":
-                        self.send_notification("Eye Protection", "Look away 20ft for 20 seconds")
-                        self.eye_protection()
+        
+        if self.eye_care_selection.get() == "On":
+            if checkbox == "On" and self.timer_manager.timer_running:
+                self.send_notification("Eye Protection", "It's time for a 20/20/20 break! Look away for 20 seconds at something 20 feet away.")
+            elif checkbox == "Off":
+                self.send_notification("Eye Protection", "It's time for a 20/20/20 break! Look away for 20 seconds at something 20 feet away.")
+        
+        # Schedule the next iteration
+        if self.eye_care_selection.get() == "On":
+            self.WINDOW.after(time_between * 1000, self.eye_protection)
+        else:
+            self.WINDOW.after(10 * 1000, self.eye_protection)
+
+
+    def auto_break(self):
+        time_between = self.data_manager.autobreak_frequency * 60
+
+        def try_timer():
+            if self.timer_manager.break_time % self.data_manager.autobreak_duration == 0: 
+                self.timer_manager.timer_mechanism(self.timer_button, self.break_button, self.time_display_label)
             else:
-                time.sleep(10)
-                self.eye_protection()
+                self.WINDOW.after(1000, try_timer)
+        
+        if self.autobreak_switch.get() == "On" and self.timer_manager.timer_running and self.timer_manager.timer_time % time_between == 0:
+            self.timer_manager.break_mechanism(self.break_button, self.timer_button, self.break_display_label)
+            self.send_notification("Auto-break", f"Time for a {self.data_manager.autobreak_duration}-minute")
+            self.WINDOW.after(self.data_manager.autobreak_duration * 60 * 1000, try_timer)
+            round(self.timer_manager.break_time, -1)
+        
+        self.WINDOW.after(100, self.auto_break)  # Schedule next iteration
 
 
     def load_history(self):
@@ -870,8 +905,6 @@ def save_on_quit(self) -> None:
         self.save_data()
         print("Data saved on exit.")
 
-        self.stop_event.set()
-
         self.workbook.save(self.data_file)
 
         self.WINDOW.destroy()