reset buttom canvas on klick any button

core/data_processing.py

@@ -45,7 +45,7 @@ class DataProcessing:
         app_logger.log(f"Combined exclusion patterns: {final_patterns}")
         return final_patterns
 
-    def get_folder_size_threaded(self, path, button_text, stop_event, exclude_patterns=None):
+    def get_folder_size_threaded(self, path, button_text, stop_event, exclude_patterns=None, mode='backup'):
         total_size = 0
         if exclude_patterns is None:
             exclude_patterns = []
@@ -78,13 +78,20 @@ class DataProcessing:
                             pass
 
         if not stop_event.is_set():
-            self.app.queue.put((button_text, total_size))
+            self.app.queue.put((button_text, total_size, mode))
 
     def process_queue(self):
         try:
             message = self.app.queue.get_nowait()
-            button_text, folder_size = message
-            self.app.source_size_bytes = folder_size
+            button_text, folder_size, mode_when_started = message
+
+            if mode_when_started != self.app.mode:
+                return # Discard stale result from a different mode
+
+            if self.app.mode == 'restore':
+                self.app.restore_destination_folder_size_bytes = folder_size
+            else:  # backup mode
+                self.app.source_size_bytes = folder_size
 
             current_folder_name = self.app.left_canvas_data.get('folder')
             if current_folder_name == button_text:
@@ -93,7 +100,6 @@ class DataProcessing:
                     self.app.left_canvas_animation.destroy()
                     self.app.left_canvas_animation = None
                 
-                # Only enable the button if the OTHER calculation is not running.
                 if not self.app.right_canvas_data.get('calculating', False):
                     self.app.start_pause_button.config(state="normal")
 
@@ -107,21 +113,26 @@ class DataProcessing:
                 self.app.left_canvas_data['calculating'] = False
                 self.app.drawing.redraw_left_canvas()
 
-            total_disk_size, _, _ = shutil.disk_usage(
-                AppConfig.FOLDER_PATHS[button_text])
-            if folder_size > total_disk_size:
-                self.app.source_larger_than_partition = True
-            else:
-                self.app.source_larger_than_partition = False
+            if self.app.mode == 'backup':
+                total_disk_size, _, _ = shutil.disk_usage(
+                    AppConfig.FOLDER_PATHS[button_text])
+                if folder_size > total_disk_size:
+                    self.app.source_larger_than_partition = True
+                else:
+                    self.app.source_larger_than_partition = False
 
-            percentage = (folder_size / total_disk_size) * 100
-            self.app.source_size_canvas.delete("all")
-            fill_width = (
-                self.app.source_size_canvas.winfo_width() / 100) * percentage
-            self.app.source_size_canvas.create_rectangle(
-                0, 0, fill_width, self.app.source_size_canvas.winfo_height(), fill="#0078d7", outline="")
-            self.app.source_size_label.config(
-                text=f"{folder_size / (1024**3):.2f} GB / {total_disk_size / (1024**3):.2f} GB")
+                if total_disk_size > 0:
+                    percentage = (folder_size / total_disk_size) * 100
+                else:
+                    percentage = 0
+                    
+                self.app.source_size_canvas.delete("all")
+                fill_width = (
+                    self.app.source_size_canvas.winfo_width() / 100) * percentage
+                self.app.source_size_canvas.create_rectangle(
+                    0, 0, fill_width, self.app.source_size_canvas.winfo_height(), fill="#0078d7", outline="")
+                self.app.source_size_label.config(
+                    text=f"{folder_size / (1024**3):.2f} GB / {total_disk_size / (1024**3):.2f} GB")
 
             self.app.drawing.update_target_projection()
 

main_app.py

@@ -96,6 +96,8 @@ class MainApplication(tk.Tk):
 
         self.left_canvas_data = {}
         self.right_canvas_data = {}
+        self.restore_destination_folder_size_bytes = 0
+        self.restore_source_size_bytes = 0
         try:
             lx_backup_icon = self.image_manager.get_icon('lx_backup_large')
             if lx_backup_icon:
@@ -276,10 +278,15 @@ class MainApplication(tk.Tk):
 
         restore_label_frame_after = ttk.Frame(self.restore_size_frame_after)
         restore_label_frame_after.grid(row=1, column=0, sticky="ew")
+
         self.restore_size_label_after = ttk.Label(
             restore_label_frame_after, text="0.00 GB / 0.00 GB")
         self.restore_size_label_after.pack(side=tk.RIGHT)
 
+        self.restore_size_label_diff = ttk.Label(
+            restore_label_frame_after, text="")
+        self.restore_size_label_diff.pack(side=tk.RIGHT)
+
         self._load_state_and_initialize()
         self.update_backup_options_from_config()  # Add this call
         self.protocol("WM_DELETE_WINDOW", self.on_closing)

pyimage_ui/actions.py

@@ -46,6 +46,7 @@ class Actions:
             # We don't set the value here, preserving the user's last choice.
 
     def on_sidebar_button_click(self, button_text):
+        self.app.drawing.reset_projection_canvases()
         if not self.app.canvas_frame.winfo_viewable():
             self.app.navigation.toggle_mode(self.app.mode, trigger_calculation=False)
 
@@ -56,6 +57,15 @@ class Actions:
             self.app.start_pause_button.config(state="disabled")
             return
 
+        if self.app.mode == 'restore':
+            try:
+                total, used, free = shutil.disk_usage(str(folder_path))
+                self.app.destination_total_bytes = total
+                self.app.destination_used_bytes = used
+            except FileNotFoundError:
+                app_logger.log(f"Path not found for disk usage: {folder_path}")
+                return
+
         icon_name = self.app.buttons_map[button_text]['icon']
 
         # Determine the correct description based on mode and selection
@@ -110,7 +120,7 @@ class Actions:
 
         self.app.calculation_stop_event = threading.Event()
         self.app.calculation_thread = threading.Thread(target=self.app.data_processing.get_folder_size_threaded, args=(
-            folder_path, button_text, self.app.calculation_stop_event, exclude_patterns))
+            folder_path, button_text, self.app.calculation_stop_event, exclude_patterns, self.app.mode))
         self.app.calculation_thread.daemon = True
         self.app.calculation_thread.start()
 
@@ -120,6 +130,7 @@ class Actions:
             self.app.config_manager.set_setting("restore_destination_path", folder_path)
 
     def on_right_canvas_click(self, event):
+        self.app.drawing.reset_projection_canvases()
         self.app.after(100, self._open_source_or_destination_dialog)
 
     def _open_source_or_destination_dialog(self):

pyimage_ui/drawing.py

@@ -183,6 +183,7 @@ class Drawing:
         else:
             size_gb = total_size / (1024**3)
             size_text = f"{size_gb:.2f} GB"
+            self.app.restore_source_size_bytes = total_size
 
         def update_ui():
             self.app.right_canvas_data['size'] = size_text
@@ -295,28 +296,47 @@ class Drawing:
             self.app.after(50, self.update_restore_projection_after)
             return
 
-        projected_total_used = self.app.destination_used_bytes + self.app.source_size_bytes
-        projected_total_percentage = projected_total_used / \
-            self.app.destination_total_bytes
+        destination_folder_bytes = getattr(self.app, 'restore_destination_folder_size_bytes', 0)
+        source_bytes = getattr(self.app, 'restore_source_size_bytes', 0)
+
+        size_diff_bytes = source_bytes - destination_folder_bytes
+        projected_total_used = self.app.destination_used_bytes + size_diff_bytes
+
+        if self.app.destination_total_bytes > 0:
+            projected_total_percentage = projected_total_used / self.app.destination_total_bytes
+        else:
+            projected_total_percentage = 0
 
         if projected_total_percentage >= 0.95:
-            canvas.create_rectangle(0, 0, canvas_width, canvas.winfo_height(
-            ), fill="#ff0000", outline="")  # Red bar
+            canvas.create_rectangle(0, 0, canvas_width, canvas.winfo_height(),
+                                    fill="#ff0000", outline="")  # Red bar
         elif projected_total_percentage >= 0.90:
-            canvas.create_rectangle(0, 0, canvas_width, canvas.winfo_height(
-            ), fill="#ff8c00", outline="")  # Orange bar
+            canvas.create_rectangle(0, 0, canvas_width, canvas.winfo_height(),
+                                    fill="#ff8c00", outline="")  # Orange bar
         else:
-            used_percentage = self.app.destination_used_bytes / \
-                self.app.destination_total_bytes
-            used_width = canvas_width * used_percentage
-            canvas.create_rectangle(
-                0, 0, used_width, canvas.winfo_height(), fill="#0078d7", outline="")
+            if self.app.destination_total_bytes > 0:
+                used_percentage = self.app.destination_used_bytes / self.app.destination_total_bytes
+                used_width = canvas_width * used_percentage
+                canvas.create_rectangle(
+                    0, 0, used_width, canvas.winfo_height(), fill="#0078d7", outline="")
 
-            projected_percentage = self.app.source_size_bytes / \
-                self.app.destination_total_bytes
-            projected_width = canvas_width * projected_percentage
-            canvas.create_rectangle(used_width, 0, used_width + projected_width,
-                                    canvas.winfo_height(), fill="#ff8c00", outline="")
+                if size_diff_bytes > 0:
+                    projected_percentage = size_diff_bytes / self.app.destination_total_bytes
+                    projected_width = canvas_width * projected_percentage
+                    canvas.create_rectangle(used_width, 0, used_width + projected_width,
+                                            canvas.winfo_height(), fill="#ff8c00", outline="")
+                elif size_diff_bytes < 0:
+                    final_used_width = canvas_width * (projected_total_used / self.app.destination_total_bytes)
+                    canvas.delete("all")
+                    canvas.create_rectangle(
+                        0, 0, final_used_width, canvas.winfo_height(), fill="#0078d7", outline="")
+
+        size_diff_gb = size_diff_bytes / (1024**3)
+        diff_text = f"+{size_diff_gb:.2f} GB" if size_diff_gb >= 0 else f"{size_diff_gb:.2f} GB"
+        
+        diff_color = "blue"
+
+        self.app.restore_size_label_diff.config(text=diff_text, foreground=diff_color)
 
         self.app.restore_size_label_after.config(
             text=f"{projected_total_used / (1024**3):.2f} GB / {self.app.destination_total_bytes / (1024**3):.2f} GB")
@@ -330,3 +350,27 @@ class Drawing:
             else:
                 button.configure(style="Gray.Toolbutton")
                 self.app.nav_progress_bars[i].pack_forget()
+
+    def reset_projection_canvases(self):
+        # Reset data variables related to size calculations
+        self.app.source_size_bytes = 0
+        self.app.restore_source_size_bytes = 0
+        self.app.restore_destination_folder_size_bytes = 0
+        self.app.source_larger_than_partition = False
+
+        # Clear backup mode canvases and labels
+        self.app.source_size_canvas.delete("all")
+        self.app.target_size_canvas.delete("all")
+        self.app.source_size_label.config(text="0.00 GB / 0.00 GB")
+        self.app.target_size_label.config(text="0.00 GB / 0.00 GB")
+
+        # Clear restore mode canvases and labels
+        self.app.restore_size_canvas_before.delete("all")
+        self.app.restore_size_canvas_after.delete("all")
+        self.app.restore_size_label_before.config(text="0.00 GB / 0.00 GB")
+        self.app.restore_size_label_after.config(text="0.00 GB / 0.00 GB")
+        if hasattr(self.app, 'restore_size_label_diff'):
+            self.app.restore_size_label_diff.config(text="")
+
+        # Also reset the main info label
+        self.app.info_label.config(text="")

pyimage_ui/navigation.py

@@ -94,6 +94,7 @@ class Navigation:
         self.app.drawing.redraw_right_canvas()
 
     def toggle_mode(self, mode=None, active_index=None, trigger_calculation=True):
+        self.app.drawing.reset_projection_canvases()
         self._cancel_calculation()
 
         # Save current state before switching