shinestacker 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

shinestacker/retouch/image_editor.py

@@ -1,73 +1,68 @@
-import traceback
-import numpy as np
-from PySide6.QtWidgets import (QMainWindow, QFileDialog, QMessageBox, QAbstractItemView,
-                               QVBoxLayout, QLabel, QDialog, QApplication)
-from PySide6.QtGui import QPixmap, QPainter, QColor, QImage, QPen, QBrush, QGuiApplication, QCursor
-from PySide6.QtCore import Qt, QTimer, QEvent, QPoint
+from PySide6.QtWidgets import QMainWindow, QMessageBox, QAbstractItemView
+from PySide6.QtGui import QPixmap, QPainter, QColor, QPen, QBrush
+from PySide6.QtCore import Qt, QPoint
 from .. config.constants import constants
 from .. config.gui_constants import gui_constants
-from .brush import Brush
-from .brush_controller import BrushController
 from .undo_manager import UndoManager
-from .file_loader import FileLoader
-from .exif_data import ExifData
 from .layer_collection import LayerCollection
-from .io_manager import IOManager
+from .io_gui_handler import IOGuiHandler
 from .brush_gradient import create_brush_gradient
+from .display_manager import DisplayManager
+from .brush_tool import BrushTool
 
 
 class ImageEditor(QMainWindow):
     def __init__(self):
         super().__init__()
-        self.layer_collection = LayerCollection()
-        self.io_manager = IOManager(self.layer_collection)
-        self.view_mode = 'master'
-        self.temp_view_individual = False
-        self.modified = False
-        self.installEventFilter(self)
-        self.update_timer = QTimer(self)
-        self.update_timer.setInterval(gui_constants.PAINT_REFRESH_TIMER)
-        self.update_timer.timeout.connect(self.process_pending_updates)
-        self.needs_update = False
-        self.brush = Brush()
-        self.brush_controller = BrushController(self.brush)
+        layer_collection = LayerCollection()
+        layer_collection.add_to(self)
         self.undo_manager = UndoManager()
         self.undo_action = None
         self.redo_action = None
         self.undo_manager.stack_changed.connect(self.update_undo_redo_actions)
-        self.loader_thread = None
+        self.io_gui_handler = None
+        self.display_manager = None
+        self.brush_tool = BrushTool()
+        self.modified = False
+        self.installEventFilter(self)
+
+    def setup_ui(self):
+        self.display_manager = DisplayManager(self.layer_collection, self.image_viewer,
+                                              self.master_thumbnail_label, self.thumbnail_list, parent=self)
+        self.io_gui_handler = IOGuiHandler(self.layer_collection, self.undo_manager, parent=self)
+        self.display_manager.status_message_requested.connect(self.show_status_message)
+        self.display_manager.cursor_preview_state_changed.connect(
+            lambda state: setattr(self.image_viewer, 'allow_cursor_preview', state))
+        self.io_gui_handler.status_message_requested.connect(self.show_status_message)
+        self.io_gui_handler.update_title_requested.connect(self.update_title)
+        self.brush_tool.setup_ui(self.brush, self.brush_preview, self.image_viewer,
+                                 self.brush_size_slider, self.hardness_slider, self.opacity_slider,
+                                 self.flow_slider)
+        self.image_viewer.brush = self.brush_tool.brush
+        self.brush_tool.update_brush_thumb()
+        self.io_gui_handler.setup_ui(self.display_manager, self.image_viewer)
+        self.image_viewer.display_manager = self.display_manager
+
+    def show_status_message(self, message):
+        self.statusBar().showMessage(message)
 
     def keyPressEvent(self, event):
         if self.image_viewer.empty:
             return
-        elif event.text() == '[':
-            self.decrease_brush_size()
+        if event.text() == '[':
+            self.brush_tool.decrease_brush_size()
             return
-        elif event.text() == ']':
-            self.increase_brush_size()
+        if event.text() == ']':
+            self.brush_tool.increase_brush_size()
             return
-        elif event.text() == '{':
-            self.decrease_brush_hardness()
+        if event.text() == '{':
+            self.brush_tool.decrease_brush_hardness()
             return
-        elif event.text() == '}':
-            self.increase_brush_hardness()
+        if event.text() == '}':
+            self.brush_tool.increase_brush_hardness()
             return
         super().keyPressEvent(event)
 
-    def process_pending_updates(self):
-        if self.needs_update:
-            self.display_master_layer()
-            self.needs_update = False
-
-    def eventFilter(self, obj, event):
-        if event.type() == QEvent.KeyPress and event.key() == Qt.Key_X:
-            self.start_temp_view()
-            return True
-        elif event.type() == QEvent.KeyRelease and event.key() == Qt.Key_X:
-            self.end_temp_view()
-            return True
-        return super().eventFilter(obj, event)
-
     def _check_unsaved_changes(self) -> bool:
         if self.modified:
             reply = QMessageBox.question(
@@ -78,328 +73,52 @@ class ImageEditor(QMainWindow):
             if reply == QMessageBox.Save:
                 self.save_file()
                 return True
-            elif reply == QMessageBox.Discard:
+            if reply == QMessageBox.Discard:
                 return True
-            else:
-                return False
-        else:
-            return True
+            return False
+        return True
 
     def sort_layers(self, order):
-        self.layer_collection.sort_layers(order)
-        self.update_thumbnails()
-        self.change_layer(self.layer_collection.current_layer)
+        self.sort_layers(order)
+        self.display_manager.update_thumbnails()
+        self.change_layer(self.current_layer())
 
     def update_title(self):
         title = constants.APP_TITLE
-        if self.io_manager.current_file_path:
-            title += f" - {self.io_manager.current_file_path.split('/')[-1]}"
-            if self.modified:
-                title += " *"
+        if self.io_gui_handler is not None:
+            path = self.io_gui_handler.io_manager.current_file_path
+            if path != '':
+                title += f" - {path.split('/')[-1]}"
+                if self.modified:
+                    title += " *"
         self.window().setWindowTitle(title)
 
-    def open_file(self, file_paths=None):
-        if file_paths is None:
-            file_paths, _ = QFileDialog.getOpenFileNames(
-                self, "Open Image", "", "Images (*.tif *.tiff *.jpg *.jpeg);;All Files (*)")
-        if not file_paths:
-            return
-        if self.loader_thread and self.loader_thread.isRunning():
-            if not self.loader_thread.wait(10000):
-                raise RuntimeError("Loading timeout error.")
-        if isinstance(file_paths, list) and len(file_paths) > 1:
-            self.import_frames_from_files(file_paths)
-            return
-        path = file_paths[0] if isinstance(file_paths, list) else file_paths
-        self.io_manager.current_file_path = path
-        QGuiApplication.setOverrideCursor(QCursor(Qt.BusyCursor))
-        self.loading_dialog = QDialog(self)
-        self.loading_dialog.setWindowTitle("Loading")
-        self.loading_dialog.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
-        self.loading_dialog.setModal(True)
-        layout = QVBoxLayout()
-        layout.addWidget(QLabel("File loading..."))
-        self.loading_dialog.setLayout(layout)
-        self.loading_timer = QTimer()
-        self.loading_timer.setSingleShot(True)
-        self.loading_timer.timeout.connect(self.loading_dialog.show)
-        self.loading_timer.start(100)
-        self.loader_thread = FileLoader(path)
-        self.loader_thread.finished.connect(self.on_file_loaded)
-        self.loader_thread.error.connect(self.on_file_error)
-        self.loader_thread.start()
-
-    def on_file_loaded(self, stack, labels, master_layer):
-        QApplication.restoreOverrideCursor()
-        self.loading_timer.stop()
-        self.loading_dialog.hide()
-        self.layer_collection.layer_stack = stack
-        if labels is None:
-            self.layer_collection.layer_labels = [f'Layer {i:03d}' for i in range(len(stack))]
-        else:
-            self.layer_collection.layer_labels = labels
-        self.layer_collection.master_layer = master_layer
-        self.modified = False
-        self.undo_manager.reset()
-        self.blank_layer = np.zeros(master_layer.shape[:2])
-        self.update_thumbnails()
-        self.image_viewer.setup_brush_cursor()
-        self.change_layer(0)
-        self.image_viewer.reset_zoom()
-        self.statusBar().showMessage(f"Loaded: {self.io_manager.current_file_path}")
-        self.thumbnail_list.setFocus()
-        self.update_title()
-
-    def on_file_error(self, error_msg):
-        QApplication.restoreOverrideCursor()
-        self.loading_timer.stop()
-        self.loading_dialog.accept()
-        self.loading_dialog.deleteLater()
-        QMessageBox.critical(self, "Error", error_msg)
-        self.statusBar().showMessage(f"Error loading: {self.io_manager.current_file_path}")
-
     def mark_as_modified(self):
         self.modified = True
         self.update_title()
 
-    def import_frames(self):
-        file_paths, _ = QFileDialog.getOpenFileNames(self, "Select frames", "",
-                                                     "Images Images (*.tif *.tiff *.jpg *.jpeg);;All Files (*)")
-        if file_paths:
-            self.import_frames_from_files(file_paths)
-        self.statusBar().showMessage("Imported selected frames")
-
-    def import_frames_from_files(self, file_paths):
-        try:
-            stack, labels, master = self.io_manager.import_frames(file_paths)
-        except Exception as e:
-            msg = QMessageBox()
-            msg.setIcon(QMessageBox.Critical)
-            msg.setWindowTitle("Import error")
-            msg.setText(str(e))
-            msg.exec()
-            return
-        if self.layer_collection.layer_stack is None and len(stack) > 0:
-            self.layer_collection.layer_stack = np.array(stack)
-            self.layer_collection.layer_labels = labels
-            self.layer_collection.master_layer = master
-            self.blank_layer = np.zeros(master.shape[:2])
-        else:
-            for img, label in zip(stack, labels):
-                self.layer_collection.layer_labels.append(label)
-                self.layer_collection.layer_stack = np.append(
-                    self.layer_collection.layer_stack, [img], axis=0)
-        self.mark_as_modified()
-        self.change_layer(0)
-        self.image_viewer.reset_zoom()
-        self.thumbnail_list.setFocus()
-        self.update_thumbnails()
-
-    def save_file(self):
-        if self.save_master_only.isChecked():
-            self.save_master()
-        else:
-            self.save_multilayer()
-
-    def save_file_as(self):
-        if self.save_master_only.isChecked():
-            self.save_master_as()
-        else:
-            self.save_multilayer_as()
-
-    def save_multilayer(self):
-        if self.layer_collection.layer_stack is None:
-            return
-        if self.current_file_path != '':
-            extension = self.current_file_path.split('.')[-1]
-            if extension in ['tif', 'tiff']:
-                self.save_multilayer_to_path(self.current_file_path)
-                return
-        self.save_multilayer_file_as()
-
-    def save_multilayer_as(self):
-        if self.layer_collection.layer_stack is None:
-            return
-        path, _ = QFileDialog.getSaveFileName(self, "Save Image", "",
-                                              "TIFF Files (*.tif *.tiff);;All Files (*)")
-        if path:
-            if not path.lower().endswith(('.tif', '.tiff')):
-                path += '.tif'
-            self.save_multilayer_to_path(path)
-
-    def save_multilayer_to_path(self, path):
-        try:
-            self.io_manager.save_multilayer(path)
-            self.io_manager.current_file_path = path
-            self.modified = False
-            self.update_title()
-            self.statusBar().showMessage(f"Saved multilayer to: {path}")
-        except Exception as e:
-            traceback.print_tb(e.__traceback__)
-            QMessageBox.critical(self, "Save Error", f"Could not save file: {str(e)}")
-
-    def save_master(self):
-        if self.layer_collection.master_layer is None:
-            return
-        if self.current_file_path != '':
-            self.save_master_to_path(self.current_file_path)
-            return
-        self.save_master_as()
-
-    def save_master_as(self):
-        if self.layer_collection.layer_stack is None:
-            return
-        path, _ = QFileDialog.getSaveFileName(self, "Save Image", "",
-                                              "TIFF Files (*.tif *.tiff);;JPEG Files (*.jpg *.jpeg);;All Files (*)")
-        if path:
-            self.save_master_to_path(path)
-
-    def save_master_to_path(self, path):
-        try:
-            self.io_manager.save_master(path)
-            self.io_manager.current_file_path = path
-            self.modified = False
-            self.update_title()
-            self.statusBar().showMessage(f"Saved master layer to: {path}")
-        except Exception as e:
-            traceback.print_tb(e.__traceback__)
-            QMessageBox.critical(self, "Save Error", f"Could not save file: {str(e)}")
-
-    def select_exif_path(self):
-        path, _ = QFileDialog.getOpenFileName(None, "Select file with exif data")
-        if path:
-            self.io_manager.set_exif_data(path)
-            self.statusBar().showMessage(f"EXIF data extracted from {path}.")
-        self._exif_dialog = ExifData(self.io_manager.exif_data, self)
-        self._exif_dialog.exec()
-
-    def close_file(self):
-        if self._check_unsaved_changes():
-            self.layer_collection.master_layer = None
-            self.blank_layer = None
-            self.current_stack = None
-            self.layer_collection.master_layer = None
-            self.layer_collection.current_layer_idx = 0
-            self.io_manager.current_file_path = ''
-            self.modified = False
-            self.undo_manager.reset()
-            self.image_viewer.clear_image()
-            self.update_thumbnails()
-            self.update_title()
-
-    def set_view_master(self):
-        self.view_mode = 'master'
-        self.temp_view_individual = False
-        self.display_master_layer()
-        self.statusBar().showMessage("View mode: Master")
-
-    def set_view_individual(self):
-        self.view_mode = 'individual'
-        self.temp_view_individual = False
-        self.display_current_layer()
-        self.statusBar().showMessage("View mode: Individual layers")
-
-    def start_temp_view(self):
-        if not self.temp_view_individual and self.view_mode == 'master':
-            self.temp_view_individual = True
-            self.image_viewer.update_brush_cursor()
-            self.display_current_layer()
-            self.statusBar().showMessage("Temporary view: Individual layer (hold X)")
-
-    def end_temp_view(self):
-        if self.temp_view_individual:
-            self.temp_view_individual = False
-            self.image_viewer.update_brush_cursor()
-            self.display_master_layer()
-            self.statusBar().showMessage("View mode: Master")
-
-    def display_current_view(self):
-        if self.temp_view_individual or self.view_mode == 'individual':
-            self.display_current_layer()
-        else:
-            self.display_master_layer()
-
-    def display_master_layer(self):
-        if self.layer_collection.master_layer is None:
-            self.image_viewer.clear_image()
-        else:
-            qimage = self.numpy_to_qimage(self.layer_collection.master_layer)
-            self.image_viewer.set_image(qimage)
-
-    def create_thumbnail(self, layer, size):
-        if layer.dtype == np.uint16:
-            layer = (layer // 256).astype(np.uint8)
-        height, width = layer.shape[:2]
-        if layer.ndim == 3 and layer.shape[-1] == 3:
-            qimg = QImage(layer.data, width, height, 3 * width, QImage.Format_RGB888)
-        else:
-            qimg = QImage(layer.data, width, height, width, QImage.Format_Grayscale8)
-        return QPixmap.fromImage(qimg.scaled(*gui_constants.UI_SIZES['thumbnail'], Qt.KeepAspectRatio))
-
-    def update_master_thumbnail(self):
-        if self.layer_collection.master_layer is None:
-            self.master_thumbnail_label.clear()
-        else:
-            thumb_size = gui_constants.UI_SIZES['thumbnail']
-            master_thumb = self.create_thumbnail(self.layer_collection.master_layer, thumb_size)
-            self.master_thumbnail_label.setPixmap(master_thumb)
-
-    def update_thumbnails(self):
-        self.update_master_thumbnail()
-        self.thumbnail_list.clear()
-        thumb_size = gui_constants.UI_SIZES['thumbnail']
-        if self.layer_collection.layer_stack is None:
-            return
-        for i, (layer, label) in enumerate(zip(self.layer_collection.layer_stack, self.layer_collection.layer_labels)):
-            thumbnail = self.create_thumbnail(layer, thumb_size)
-            self._add_thumbnail_item(thumbnail, label, i, i == self.layer_collection.current_layer_idx)
-
-    def _add_thumbnail_item(self, thumbnail, label, i, is_current):
-        pass
-
     def change_layer(self, layer_idx):
-        if 0 <= layer_idx < self.layer_collection.number_of_layers():
+        if 0 <= layer_idx < self.number_of_layers():
             view_state = self.image_viewer.get_view_state()
-            self.layer_collection.current_layer_idx = layer_idx
-            self.display_current_view()
+            self.set_current_layer_idx(layer_idx)
+            self.display_manager.display_current_view()
             self.image_viewer.set_view_state(view_state)
             self.thumbnail_list.setCurrentRow(layer_idx)
             self.thumbnail_list.setFocus()
             self.image_viewer.update_brush_cursor()
             self.image_viewer.setFocus()
 
-    def display_current_layer(self):
-        if self.layer_collection.layer_stack is None:
-            return
-        layer = self.layer_collection.current_layer()
-        qimage = self.numpy_to_qimage(layer)
-        self.image_viewer.set_image(qimage)
-
-    def numpy_to_qimage(self, array):
-        if array.dtype == np.uint16:
-            array = np.right_shift(array, 8).astype(np.uint8)
-
-        if array.ndim == 2:
-            height, width = array.shape
-            return QImage(memoryview(array), width, height, width, QImage.Format_Grayscale8)
-        elif array.ndim == 3:
-            height, width, _ = array.shape
-            if not array.flags['C_CONTIGUOUS']:
-                array = np.ascontiguousarray(array)
-            return QImage(memoryview(array), width, height, 3 * width, QImage.Format_RGB888)
-        return QImage()
-
     def prev_layer(self):
-        if self.layer_collection.layer_stack is not None:
-            new_idx = max(0, self.layer_collection.current_layer_idx - 1)
-            if new_idx != self.layer_collection.current_layer_idx:
+        if self.layer_stack() is not None:
+            new_idx = max(0, self.current_layer_idx() - 1)
+            if new_idx != self.current_layer_idx():
                 self.change_layer(new_idx)
                 self.highlight_thumbnail(new_idx)
 
     def next_layer(self):
-        if self.layer_collection.layer_stack is not None:
-            new_idx = min(self.layer_collection.number_of_layers() - 1, self.layer_collection.current_layer_idx + 1)
-            if new_idx != self.layer_collection.current_layer_idx:
+        if self.layer_stack() is not None:
+            new_idx = min(self.number_of_layers() - 1, self.current_layer_idx() + 1)
+            if new_idx != self.current_layer_idx():
                 self.change_layer(new_idx)
                 self.highlight_thumbnail(new_idx)
 
@@ -407,48 +126,34 @@ class ImageEditor(QMainWindow):
         self.thumbnail_list.setCurrentRow(index)
         self.thumbnail_list.scrollToItem(self.thumbnail_list.item(index), QAbstractItemView.PositionAtCenter)
 
-    def update_brush_size(self, slider_val):
-
-        def slider_to_brush_size(slider_val):
-            normalized = slider_val / gui_constants.BRUSH_SIZE_SLIDER_MAX
-            size = gui_constants.BRUSH_SIZES['min'] + \
-                gui_constants.BRUSH_SIZES['max'] * (normalized ** gui_constants.BRUSH_GAMMA)
-            return max(gui_constants.BRUSH_SIZES['min'], min(gui_constants.BRUSH_SIZES['max'], size))
-
-        self.brush.size = slider_to_brush_size(slider_val)
-        self.update_brush_thumb()
-
-    def increase_brush_size(self, amount=5):
-        val = min(self.brush_size_slider.value() + amount, self.brush_size_slider.maximum())
-        self.brush_size_slider.setValue(val)
-        self.update_brush_size(val)
-
-    def decrease_brush_size(self, amount=5):
-        val = max(self.brush_size_slider.value() - amount, self.brush_size_slider.minimum())
-        self.brush_size_slider.setValue(val)
-        self.update_brush_size(val)
-
-    def increase_brush_hardness(self, amount=2):
-        val = min(self.hardness_slider.value() + amount, self.hardness_slider.maximum())
-        self.hardness_slider.setValue(val)
-        self.update_brush_hardness(val)
-
-    def decrease_brush_hardness(self, amount=2):
-        val = max(self.hardness_slider.value() - amount, self.hardness_slider.minimum())
-        self.hardness_slider.setValue(val)
-        self.update_brush_hardness(val)
-
-    def update_brush_hardness(self, hardness):
-        self.brush.hardness = hardness
-        self.update_brush_thumb()
-
-    def update_brush_opacity(self, opacity):
-        self.brush.opacity = opacity
-        self.update_brush_thumb()
+    def copy_layer_to_master(self):
+        if self.layer_stack() is None or self.master_layer() is None:
+            return
+        reply = QMessageBox.question(
+            self,
+            "Confirm Copy",
+            "Warning: the current master layer will be erased\n\nDo you want to continue?",
+            QMessageBox.Yes | QMessageBox.No,
+            QMessageBox.No
+        )
+        if reply == QMessageBox.Yes:
+            self.set_master_layer(self.current_layer().copy())
+            self.master_layer().setflags(write=True)
+            self.display_manager.display_current_view()
+            self.display_manager.update_thumbnails()
+            self.mark_as_modified()
+            self.statusBar().showMessage(f"Copied layer {self.current_layer_idx() + 1} to master")
 
-    def update_brush_flow(self, flow):
-        self.brush.flow = flow
-        self.update_brush_thumb()
+    def copy_brush_area_to_master(self, view_pos):
+        if self.layer_stack() is None or self.number_of_layers() == 0 \
+           or not self.display_manager.allow_cursor_preview():
+            return
+        area = self.brush_tool.apply_brush_operation(
+            self.master_layer_copy(),
+            self.current_layer(),
+            self.master_layer(), self.mask_layer,
+            view_pos, self.image_viewer)
+        self.undo_manager.extend_undo_area(*area)
 
     def update_brush_thumb(self):
         width, height = gui_constants.UI_SIZES['brush_preview']
@@ -486,62 +191,31 @@ class ImageEditor(QMainWindow):
         self.brush_preview.setPixmap(pixmap)
         self.image_viewer.update_brush_cursor()
 
-    def allow_cursor_preview(self):
-        return self.view_mode == 'master' and not self.temp_view_individual
-
-    def copy_layer_to_master(self):
-        if self.layer_collection.layer_stack is None or self.layer_collection.master_layer is None:
-            return
-        reply = QMessageBox.question(
-            self,
-            "Confirm Copy",
-            "Warning: the current master layer will be erased\n\nDo you want to continue?",
-            QMessageBox.Yes | QMessageBox.No,
-            QMessageBox.No
-        )
-        if reply == QMessageBox.Yes:
-            self.layer_collection.master_layer = self.layer_collection.current_layer().copy()
-            self.layer_collection.master_layer.setflags(write=True)
-            self.display_current_view()
-            self.update_thumbnails()
-            self.mark_as_modified()
-            self.statusBar().showMessage(f"Copied layer {self.layer_collection.current_layer_idx + 1} to master")
-
-    def copy_brush_area_to_master(self, view_pos):
-        if self.layer_collection.layer_stack is None or self.layer_collection.number_of_layers() == 0 \
-           or self.view_mode != 'master' or self.temp_view_individual:
-            return
-        area = self.brush_controller.apply_brush_operation(self.layer_collection.master_layer_copy,
-                                                           self.layer_collection.current_layer(),
-                                                           self.layer_collection.master_layer, self.mask_layer,
-                                                           view_pos, self.image_viewer)
-        self.undo_manager.extend_undo_area(*area)
-
     def begin_copy_brush_area(self, pos):
-        if self.view_mode == 'master' and not self.temp_view_individual:
-            self.mask_layer = self.blank_layer.copy()
-            self.layer_collection.copy_master_layer()
+        if self.display_manager.allow_cursor_preview():
+            self.mask_layer = self.io_gui_handler.blank_layer.copy()
+            self.copy_master_layer()
             self.undo_manager.reset_undo_area()
             self.copy_brush_area_to_master(pos)
-            self.needs_update = True
-            if not self.update_timer.isActive():
-                self.update_timer.start()
+            self.display_manager.needs_update = True
+            if not self.display_manager.update_timer.isActive():
+                self.display_manager.update_timer.start()
             self.mark_as_modified()
 
     def continue_copy_brush_area(self, pos):
-        if self.view_mode == 'master' and not self.temp_view_individual:
+        if self.display_manager.allow_cursor_preview():
             self.copy_brush_area_to_master(pos)
-            self.needs_update = True
-            if not self.update_timer.isActive():
-                self.update_timer.start()
+            self.display_manager.needs_update = True
+            if not self.display_manager.update_timer.isActive():
+                self.display_manager.update_timer.start()
             self.mark_as_modified()
 
     def end_copy_brush_area(self):
-        if self.update_timer.isActive():
-            self.display_master_layer()
-            self.update_master_thumbnail()
-            self.undo_manager.save_undo_state(self.layer_collection.master_layer_copy, 'Brush Stroke')
-            self.update_timer.stop()
+        if self.display_manager.update_timer.isActive():
+            self.display_manager.display_master_layer()
+            self.display_manager.update_master_thumbnail()
+            self.undo_manager.save_undo_state(self.master_layer_copy(), 'Brush Stroke')
+            self.display_manager.update_timer.stop()
             self.mark_as_modified()
 
     def update_undo_redo_actions(self, has_undo, undo_desc, has_redo, redo_desc):