refactor: enhance mock camera classes and update camera detection logic

feat: implement CvCamera class for OpenCV camera handling

.gitignore

@@ -216,3 +216,7 @@ __marimo__/
 
 # Streamlit
 .streamlit/secrets.toml
+
+
+media/
+*.db

controllers/camera_controller.py

@@ -0,0 +1,97 @@
+# import gphoto2 as gp
+import numpy as np
+import cv2
+
+from PySide6.QtCore import QObject, QThread, Signal
+from PySide6.QtGui import QImage, QPixmap
+
+# try:
+    # import gphoto2 as gp
+# except:
+from . import mock_gphoto as gp
+
+class CameraWorker(QObject):
+    frameReady = Signal(QPixmap)
+    errorOccurred = Signal(str)
+
+    def __init__(self, fps: int = 15, parent=None):
+        super().__init__(parent)
+        self.fps = fps
+        self.running = False
+        self.camera = None
+
+    def start_camera(self):
+        """Uruchom kamerę i zacznij pobierać klatki"""
+        try:
+            self.camera = gp.Camera()   # type: ignore
+            self.camera.init()
+            self.running = True
+            self._capture_loop()
+        except gp.GPhoto2Error as e:
+            self.errorOccurred.emit(f"Błąd inicjalizacji kamery: {e}")
+
+    def stop_camera(self):
+        """Zatrzymaj pobieranie"""
+        self.running = False
+        if self.camera:
+            try:
+                self.camera.exit()
+            except gp.GPhoto2Error:
+                pass
+            self.camera = None
+
+    def _capture_loop(self):
+        """Pętla odczytu klatek w osobnym wątku"""
+        import time
+        delay = 1.0 / self.fps
+
+        while self.running:
+            try:
+                file = self.camera.capture_preview()    # type: ignore
+                data = file.get_data_and_size()
+                frame = np.frombuffer(data, dtype=np.uint8)
+                frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
+
+                if frame is not None:
+                    rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    h, w, ch = rgb_image.shape
+                    qimg = QImage(rgb_image.data, w, h, ch * w, QImage.Format.Format_RGB888)
+                    pixmap = QPixmap.fromImage(qimg)
+                    self.frameReady.emit(pixmap)
+
+            except gp.GPhoto2Error as e:
+                self.errorOccurred.emit(f"Błąd odczytu LiveView: {e}")
+                break
+            except Exception as e:
+                self.errorOccurred.emit(f"Nieoczekiwany błąd: {e}")
+                break
+
+            time.sleep(delay)
+
+
+class CameraController(QObject):
+    frameReady = Signal(QPixmap)
+    errorOccurred = Signal(str)
+
+    def __init__(self, fps: int = 15, parent=None):
+        super().__init__(parent)
+        self.camera_thread  = QThread()
+        self.worker = CameraWorker(fps)
+        self.worker.moveToThread(self.camera_thread )
+
+        # sygnały z workera
+        self.worker.frameReady.connect(self.frameReady)
+        self.worker.errorOccurred.connect(self.errorOccurred)
+
+        # sygnały start/stop
+        self.camera_thread.started.connect(self.worker.start_camera)
+
+    def start(self):
+        """Start kamery w osobnym wątku"""
+        self.camera_thread.start()
+
+    def stop(self):
+        """Stop kamery i zakończenie wątku"""
+        self.worker.stop_camera()
+        self.camera_thread.quit()
+        self.camera_thread.wait()

controllers/main_controller.py

@@ -0,0 +1,100 @@
+from PySide6.QtWidgets import QPushButton
+from pathlib import Path
+from core.database import DatabaseManager
+from core.media import MediaRepository
+from ui.widgets.color_list_widget import ColorListWidget
+from ui.widgets.thumbnail_list_widget import ThumbnailListWidget
+from ui.widgets.split_view_widget import SplitView
+# from .camera_controller import CameraController
+from core.camera.camera_controller import CameraController
+from core.camera.camera_manager import CameraManager
+
+
+from core.camera.gphoto_camera import GPhotoCamera
+from core.camera.camera_controller import CameraController
+
+class MainController:
+	def __init__(self, view):
+		self.db = DatabaseManager()
+		self.db.connect()
+		self.media_repo = MediaRepository(self.db)
+		self.media_repo.sync_media()
+
+		# camera = GPhotoCamera()
+		# self.manager = CameraController(camera)
+		manager = CameraManager()
+		manager.detect_gphoto()
+		manager.detect_opencv()
+
+		# self.camera_controller = CameraController()
+
+		self.view = view
+		self.color_list: ColorListWidget = view.color_list_widget
+		self.thumbnail_list: ThumbnailListWidget = view.thumbnail_widget
+		self.split_view: SplitView = view.preview_widget
+
+		self.photo_button: QPushButton = view.photo_button
+		self.photo_button.clicked.connect(self.take_photo)
+
+		self.record_button: QPushButton = view.record_button
+		# self.record_button.clicked.connect(self.fun_test)
+
+		self.color_list.colorSelected.connect(self.on_color_selected)
+		self.color_list.editColor.connect(self.on_edit_color)
+		self.thumbnail_list.selectedThumbnail.connect(self.on_thumbnail_selected)
+
+		# self.camera_controller.errorOccurred.connect(self.split_view.widget_start.set_info_text)
+		# self.manager.error_occurred.connect(self.split_view.widget_start.set_info_text)
+		# self.camera_controller.frameReady.connect(self.split_view.set_live_image)
+		# self.manager.frame_ready.connect(self.split_view.set_live_image)
+		# self.split_view.widget_start.camera_start_btn.clicked.connect(self.camera_controller.start)
+		self.split_view.widget_start.camera_start_btn.clicked.connect(self.start_liveview)
+
+
+	def start_camera(self):
+		pass
+
+	def load_colors(self) -> None:
+		colors = self.db.get_all_colors()
+		print("Loaded colors:", colors)
+		self.color_list.set_colors(colors)
+
+
+	def on_color_selected(self, color_name: str):
+		print(f"Wybrano kolor: {color_name}")
+		color_id = self.db.get_color_id(color_name)
+		if color_id is not None:
+			media_items = self.db.get_media_for_color(color_id)
+			print(f"Media dla koloru {color_name} (ID: {color_id}):", media_items)
+
+			self.thumbnail_list.list_widget.clear()
+			for media in media_items:
+				if media['file_type'] == 'photo':
+					file_name = Path(media['media_path']).name
+					self.thumbnail_list.add_thumbnail(media['media_path'], file_name, media['id'])
+		else:
+			print(f"Nie znaleziono koloru o nazwie: {color_name}")
+
+	def on_edit_color(self, color_name: str):
+		print(f"Edycja koloru: {color_name}")
+
+	def on_thumbnail_selected(self, media_id: int):
+		media = self.db.get_media(media_id)
+		if media:
+			print(f"Wybrano miniaturę o ID: {media_id}, ścieżka: {media['media_path']}")
+			self.split_view.set_reference_image(media['media_path'])
+		else:
+			print(f"Nie znaleziono mediów o ID: {media_id}")
+
+	def take_photo(self):
+		print("Robienie zdjęcia...")
+		self.split_view.toglle_live_view()
+
+	def start_liveview(self):
+		pass
+		# self.manager.start_camera()
+		# self.manager.start_stream()
+
+	def shutdown(self):
+		pass
+		# self.manager.stop()

controllers/mock_gphoto.py

@@ -0,0 +1,148 @@
+import cv2
+import numpy as np
+
+GP_WIDGET_WINDOW = 0
+GP_WIDGET_SECTION = 0
+GP_WIDGET_TEXT = 0
+GP_WIDGET_RANGE = 0
+GP_WIDGET_TOGGLE = 0
+GP_WIDGET_RADIO = 0
+GP_WIDGET_MENU = 0
+GP_WIDGET_BUTTON = 0
+GP_WIDGET_DATE = 0
+
+class GPhoto2Error(Exception):
+    pass
+
+
+class CameraFileMock:
+    """Mock obiektu zwracanego przez gphoto2.Camera.capture_preview()"""
+
+    def __init__(self, frame: np.ndarray):
+        # Kodowanie do JPEG, żeby symulować prawdziwe dane z kamery
+        success, buf = cv2.imencode(".jpg", frame)
+        if not success:
+            raise GPhoto2Error("Nie udało się zakodować ramki testowej.")
+        self._data = buf.tobytes()
+
+    def get_data_and_size(self):
+        return self._data
+        return self._data, len(self._data)
+
+class CameraListMock:
+    def count(self):
+        return 1
+    
+    def get_name(self, idx):
+        return f"mock_name {idx}"
+    
+    def get_value(self, idx):
+        return f"mock_value {idx}"
+    
+class MockPortInfo:
+    def __init__(self, address):
+        self.address = address
+
+class PortInfoList:
+    def __init__(self):
+        self._ports = []
+
+    def load(self):
+        # Dodaj przykładowe porty
+        self._ports = [MockPortInfo("usb:001,002"), MockPortInfo("usb:001,003")]
+
+    def lookup_path(self, port_address):
+        for idx, port in enumerate(self._ports):
+            if port.address == port_address:
+                return idx
+        raise ValueError("Port not found")
+
+    def __getitem__(self, idx):
+        return self._ports[idx]
+
+class ConfigMock:
+    def get_id(self):
+        return 0
+    def get_name(self):
+        return "name"
+    def get_label(self):
+        return "label"
+    def get_type(self):
+        return 0
+    def get_value(self):
+        return "value"
+    def get_choices(self):
+        return []
+    def count_children(self):
+        return 0
+    def get_child(self):
+        return ConfigMock()
+
+
+class CameraAbilitiesList:
+    def __init__(self) -> None:
+        self.abilities = []
+    def load(self):
+        return
+    def lookup_model(self, name):
+        return 1
+    def get_abilities(self, abilities_index):
+        return 0
+
+class Camera:
+    def __init__(self):
+        self._frame_counter = 0
+        self._running = False
+
+    def init(self):
+        self._running = True
+        print("[my_gphoto] Kamera MOCK zainicjalizowana")
+
+    def exit(self):
+        self._running = False
+        print("[my_gphoto] Kamera MOCK wyłączona")
+
+    def capture_preview(self):
+        if not self._running:
+            raise GPhoto2Error("Kamera MOCK nie jest uruchomiona")
+
+        # przykład 1: wczytaj stały obrazek z pliku
+        # frame = cv2.imread("test_frame.jpg")
+        # if frame is None:
+        #     raise GPhoto2Error("Nie znaleziono test_frame.jpg")
+
+        # przykład 2: wygeneruj kolorową planszę
+        h, w = 480, 640
+        color = (self._frame_counter % 255, 100, 200)
+        frame = np.full((h, w, 3), color, dtype=np.uint8)
+
+        # dodanie napisu
+        text = "OBRAZ TESTOWY"
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        scale = 1.5
+        thickness = 3
+        color_text = (255, 255, 255)
+
+        (text_w, text_h), _ = cv2.getTextSize(text, font, scale, thickness)
+        x = (w - text_w) // 2
+        y = (h + text_h) // 2
+        cv2.putText(frame, text, (x, y), font, scale, color_text, thickness, cv2.LINE_AA)
+
+
+        self._frame_counter += 1
+        return CameraFileMock(frame)
+    
+    def set_port_info(self, obj):
+        return False
+    
+    def get_config(self):
+        return ConfigMock()
+    
+    def set_single_config(self, name, widget):
+        return True
+
+def gp_camera_autodetect():
+    return CameraListMock()
+
+def check_result(obj):
+    return obj

core/camera/base_camera.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+
+
+class BaseCamera(ABC):
+	def __init__(self) -> None:
+		self.error_msg = None
+
+	@staticmethod
+	@abstractmethod
+	def detect() -> dict:
+		raise NotImplementedError
+
+	@abstractmethod
+	def connect(self, index: int | None = None) -> bool:
+		raise NotImplementedError
+
+	@abstractmethod
+	def disconnect(self) -> None:
+		raise NotImplementedError
+
+	@abstractmethod
+	def get_frame(self):
+		raise NotImplementedError
+
+	@abstractmethod
+	def get_config_by_id(self, id: int) -> dict:
+		raise NotImplementedError
+
+	@abstractmethod
+	def get_config_by_name(self, name: str) -> dict:
+		raise NotImplementedError
+
+	@abstractmethod
+	def set_config_by_id(self, id: int, value) -> None:
+		raise NotImplementedError
+
+	@abstractmethod
+	def set_config_by_name(self, name: str, value) -> None:
+		raise NotImplementedError
+
+	def get_error_msg(self):
+		return str(self.error_msg)

core/camera/camera_controller.py

@@ -0,0 +1,115 @@
+from PySide6.QtCore import QObject, QThread, QTimer, Signal, Slot, QMutex, QMutexLocker
+from PySide6.QtGui import QImage, QPixmap
+import cv2
+
+from .base_camera import BaseCamera
+
+
+class CameraController(QThread):
+    frame_ready = Signal(QPixmap)
+    photo_ready = Signal(QPixmap)
+    error_occurred = Signal(str)
+    _enable_timer = Signal(bool)
+
+
+    def __init__(self, parent: QObject | None = None) -> None:
+        super().__init__(parent)
+        self.camera = None
+        self.timer = None
+        self.fps = 15
+        self.is_streaming = False
+        self.is_connected = False
+
+        self._camera_mutex = QMutex()
+        self.start()
+
+
+    def run(self) -> None:
+        self.timer = QTimer()
+        self.timer.timeout.connect(self._update_frame)
+        self._enable_timer.connect(self._set_timer)
+        self.exec()
+ 
+    def stop(self):
+        self.stop_camera()
+        self.quit()
+        self.wait()
+
+    def set_camera(self, camera: BaseCamera, fps: int = 15) -> None:
+        with QMutexLocker(self._camera_mutex):
+            self.stop_stream()
+            self.stop_camera()
+
+            self.camera = camera
+            self.fps = fps
+
+    def start_camera(self) -> None:
+        if self.camera is None or self.is_connected:
+            return
+
+        if self.camera.connect():
+            self.is_connected = True
+        else:
+            self.is_connected = False
+            self.error_occurred.emit(self.camera.get_error_msg())
+
+    def stop_camera(self) -> None:
+        if self.is_streaming:
+            self.stop_stream()
+
+        if self.camera is not None:
+            self.camera.disconnect()
+
+        self.is_connected = False
+
+    def start_stream(self):
+        if not self.is_connected:
+            return
+
+        if self.is_streaming:
+            return
+
+        if self.timer:
+            self.is_streaming = True
+            # self.timer.start()
+            self._enable_timer.emit(True)
+
+    def stop_stream(self) -> None:
+        if self.is_streaming:
+            self.is_streaming = False
+            if self.timer:
+                # self.timer.stop()
+                self._enable_timer.emit(False)
+
+    def _update_frame(self) -> None:
+        with QMutexLocker(self._camera_mutex):
+            if self.camera is None or not self.is_connected:
+                return
+        
+            if not self.is_streaming:
+                return
+
+            ret, frame = self.camera.get_frame()
+
+            if not ret:
+                self.error_occurred.emit(self.camera.get_error_msg())
+                return
+
+        if frame is not None:
+            rgb_image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            h, w, ch = rgb_image.shape
+            qimg = QImage(rgb_image.data, w, h, ch * w, QImage.Format.Format_RGB888)
+            pixmap = QPixmap.fromImage(qimg)
+
+            self.frame_ready.emit(pixmap)
+
+    def _set_timer(self, enable: bool):
+        if not self.timer:
+            return
+        
+        if enable:
+            self.timer.setInterval(int(1000 / self.fps))
+            self.timer.start()
+        else:
+            self.timer.stop()
+            

core/camera/camera_manager.py

@@ -0,0 +1,20 @@
+
+
+from .gphoto_camera import GPhotoCamera
+from .opencv_camera import OpenCvCamera
+from .camera_controller import CameraController
+
+
+class CameraManager:
+	def __init__(self) -> None:
+		pass
+
+	def detect_gphoto(self):
+		camera_list = GPhotoCamera.detect()
+		print(camera_list)
+		return camera_list
+
+	def detect_opencv(self):
+		camera_list = OpenCvCamera.detect()
+		print(camera_list)
+		return camera_list

core/camera/gphoto_camera.py

@@ -0,0 +1,173 @@
+from typing import Optional, List
+from dataclasses import dataclass, field
+import cv2
+import numpy as np
+
+from .base_camera import BaseCamera
+
+try:
+	import gphoto2 as gp	# type: ignore
+except:
+	import controllers.mock_gphoto as gp
+
+camera_widget_types = {
+	gp.GP_WIDGET_WINDOW: "GP_WIDGET_WINDOW",    # type: ignore
+	gp.GP_WIDGET_SECTION: "GP_WIDGET_SECTION",  # type: ignore
+	gp.GP_WIDGET_TEXT: "GP_WIDGET_TEXT",        # type: ignore
+	gp.GP_WIDGET_RANGE: "GP_WIDGET_RANGE",      # type: ignore
+	gp.GP_WIDGET_TOGGLE: "GP_WIDGET_TOGGLE",    # type: ignore
+	gp.GP_WIDGET_RADIO: "GP_WIDGET_RADIO",      # type: ignore
+	gp.GP_WIDGET_MENU: "GP_WIDGET_MENU",        # type: ignore
+	gp.GP_WIDGET_BUTTON: "GP_WIDGET_BUTTON",    # type: ignore
+	gp.GP_WIDGET_DATE: "GP_WIDGET_DATE",        # type: ignore
+}
+
+operations = [
+    ("GP_OPERATION_NONE", gp.GP_OPERATION_NONE),						# type: ignore
+    ("GP_OPERATION_CAPTURE_IMAGE", gp.GP_OPERATION_CAPTURE_IMAGE),		# type: ignore
+    ("GP_OPERATION_CAPTURE_VIDEO", gp.GP_OPERATION_CAPTURE_VIDEO),		# type: ignore
+    ("GP_OPERATION_CAPTURE_AUDIO", gp.GP_OPERATION_CAPTURE_AUDIO),		# type: ignore
+    ("GP_OPERATION_CAPTURE_PREVIEW", gp.GP_OPERATION_CAPTURE_PREVIEW),	# type: ignore
+    ("GP_OPERATION_CONFIG", gp.GP_OPERATION_CONFIG),					# type: ignore
+    ("GP_OPERATION_TRIGGER_CAPTURE", gp.GP_OPERATION_TRIGGER_CAPTURE),	# type: ignore
+]
+
+
+class GPhotoCamera(BaseCamera):
+	def __init__(self) -> None:
+		super().__init__()
+		self.camera = None
+		self.configs: List[dict] = []
+		self.camera_index = 0
+
+	@staticmethod
+	def detect() -> dict:
+		cameras = gp.check_result(gp.gp_camera_autodetect()) # type: ignore
+		# cameras = gp.Camera().autodetect()
+		if not cameras or cameras.count() == 0:  # type: ignore
+			return {}
+		
+		abilities_list = gp.CameraAbilitiesList()	# type: ignore
+		abilities_list.load()
+		camera_list = {}
+		for i in range(cameras.count()):     # type: ignore
+			name = cameras.get_name(i)       # type: ignore
+			port = cameras.get_value(i)      # type: ignore
+
+			abilities_index = abilities_list.lookup_model(name)
+			abilities = abilities_list.get_abilities(abilities_index)
+			abilities_name = []
+			for name, bit in operations:
+					if abilities.operations & bit:	# type: ignore
+						abilities_name.append(name)
+
+			camera_list[i] = {"name": name, "port": port, "abilities": abilities_name}
+		return camera_list
+	
+	def connect(self, index: int | None = None) -> bool:
+		self.error_msg = None
+		self.camera = gp.Camera()   # type: ignore
+		
+		try:
+			if index:
+				self.camera_index = index
+				camera_list = GPhotoCamera.detect()
+				port_info_list = gp.PortInfoList()
+				port_info_list.load()
+
+				port_address = camera_list[index]["port"]
+				port_index = port_info_list.lookup_path(port_address)
+		
+				self.camera.set_port_info(port_info_list[port_index])
+		 
+			self.camera.init()
+			config = self.camera.get_config()
+			self.read_config(config)
+			return True
+		except Exception as e:
+			self.error_msg = f"[GPHOTO2] {e}"
+			self.camera = None
+			return False
+
+	def disconnect(self) -> None:
+		if self.camera:
+			self.camera.exit()
+			self.camera = None
+			self.configs.clear()
+
+	def get_frame(self):
+		self.error_msg = None
+
+		if self.camera is None:
+			self.error_msg = "[GPHOTO2] Camera is not initialized."
+			return (False, None)
+
+		try:
+			file = self.camera.capture_preview()    # type: ignore
+			data = file.get_data_and_size()
+			frame = np.frombuffer(data, dtype=np.uint8)
+			frame = cv2.imdecode(frame, cv2.IMREAD_COLOR)
+
+			return (True, frame)
+		except Exception as e:
+			self.error_msg = f"[GPHOTO2] {e}"
+			return (False, None)
+
+	def get_config_by_id(self, id: int):
+		return next(w for w in self.configs if w['id'] == id)
+
+	def get_config_by_name(self, name: str):
+		return next(w for w in self.configs if w['name'] == name)
+
+	def set_config(self, config, value):
+		if value not in config['choices']:
+			return
+
+		config['widget'].set_value(value)  # type: ignore
+		if self._save_config(config):
+			config['value'] = value
+
+	def set_config_by_id(self, id: int, value: str):
+		config = self.get_config_by_id(id)
+
+		self.set_config(config, value)
+
+	def set_config_by_name(self, name: str, value: str):
+		config = self.get_config_by_name(name)
+
+		self.set_config(config, value)
+
+	def _save_config(self, config):
+		if not self.camera:
+			return False
+
+		self.camera.set_single_config(config['name'], config['widget'])
+		return True
+
+	def parse_config(self, config):
+		new_config = {
+			"id": config.get_id(),
+			"name": config.get_name(),
+			"label": config.get_label(),
+			"type": camera_widget_types[config.get_type()],
+			"widget": config
+		}
+
+		try:
+			new_config["value"] = config.get_value()
+		except gp.GPhoto2Error:
+			pass
+
+		try:
+			new_config["choices"] = list(config.get_choices())
+		except gp.GPhoto2Error:
+			pass
+
+		return new_config
+
+	def read_config(self, config):
+		self.configs.append(self.parse_config(config))
+
+		for i in range(config.count_children()):
+			child = config.get_child(i)
+			self.read_config(child)

core/camera/opencv_camera.py

@@ -0,0 +1,122 @@
+import cv2
+from cv2_enumerate_cameras import enumerate_cameras
+from typing import List
+
+from .base_camera import BaseCamera
+
+
+class OpenCvCamera(BaseCamera):
+	"""Kamera oparta na cv2.VideoCapture"""
+
+	config_map = {
+		0: {"name": "frame_width", "cv_prop": cv2.CAP_PROP_FRAME_WIDTH, "default": 640},
+		1: {"name": "frame_height", "cv_prop": cv2.CAP_PROP_FRAME_HEIGHT, "default": 480},
+		2: {"name": "fps", "cv_prop": cv2.CAP_PROP_FPS, "default": 30},
+		3: {"name": "brightness", "cv_prop": cv2.CAP_PROP_BRIGHTNESS, "default": 0.5},
+		4: {"name": "contrast", "cv_prop": cv2.CAP_PROP_CONTRAST, "default": 0.5},
+		5: {"name": "saturation", "cv_prop": cv2.CAP_PROP_SATURATION, "default": 0.5},
+	}
+
+	def __init__(self) -> None:
+		super().__init__()
+		self.cap = None
+		self.configs: List[dict] = []
+		self.camera_list = []
+		self.camera_index = 0
+
+	@staticmethod
+	def detect():
+		camera_list = enumerate_cameras(cv2.CAP_ANY)
+		result = {}
+
+		for camera in camera_list:
+			cap = cv2.VideoCapture(camera.index, camera.backend)
+			# ret, frame = cap.read()
+			cap.release()
+
+			# if ret and frame is not None and frame.size > 0:
+			result[camera.index] = {
+				"name": camera.name,
+				"port": camera.path,
+				"backend": camera.backend,
+			}
+
+		return result
+
+	def connect(self, index: int | None = None) -> bool:
+		self.error_msg = None
+		try:
+			if index:
+				self.camera_index = index
+
+			self.cap = cv2.VideoCapture(self.camera_index)
+
+			if not self.cap.isOpened():
+				self.error_msg = f"[CV2] Could not open camera {self.camera_index}"
+				return False
+
+			self.configs.clear()
+			for id, conf in self.config_map.items():
+				value = self.cap.get(conf["cv_prop"])
+				self.configs.append(
+					{
+						"id": id,
+						"name": conf["name"],
+						"label": conf["name"].capitalize(),
+						"value": value,
+						"choices": None,  # brak predefiniowanych wyborów
+						"cv_prop": conf["cv_prop"],
+					}
+				)
+			return True
+
+		except Exception as e:
+			self.error_msg = f"[CV2] {e}"
+			self.cap = None
+			return False
+
+	def disconnect(self) -> None:
+		if self.cap:
+			self.cap.release()
+			self.cap = None
+			self.configs.clear()
+
+	def get_frame(self):
+		self.error_msg = None
+		if self.cap is None or not self.cap.isOpened():
+			self.error_msg = "[CV2] Camera is not initialized."
+			return (False, None)
+
+		try:
+			ret, frame = self.cap.read()
+			if not ret:
+				self.error_msg = "[CV2] Failed to read frame."
+				return (False, None)
+			return (True, frame)
+		except Exception as e:
+			self.error_msg = f"[CV2] {e}"
+			return (False, None)
+
+	def get_config_by_id(self, id: int):
+		return next(w for w in self.configs if w["id"] == id)
+
+	def get_config_by_name(self, name: str):
+		return next(w for w in self.configs if w["name"] == name)
+
+	def set_config(self, config, value: float):
+		if not self.cap:
+			return
+		try:
+			self.cap.set(config["cv_prop"], value)
+			config["value"] = self.cap.get(
+				config["cv_prop"])  # sprawdz co ustawiło
+		except Exception as e:
+			self.error_msg = f"[CV2] {e}"
+
+	def set_config_by_id(self, id: int, value: float):
+		config = self.get_config_by_id(id)
+		self.set_config(config, value)
+
+	def set_config_by_name(self, name: str, value: float):
+		config = self.get_config_by_name(name)
+		self.set_config(config, value)

core/database.py

@@ -0,0 +1,156 @@
+# core/database.py
+
+import sqlite3
+from pathlib import Path
+from datetime import datetime
+
+DB_FILE = Path("app.db")
+
+
+class DatabaseManager:
+    def __init__(self, db_path: Path = DB_FILE):
+        self.db_path = db_path
+        self.conn: sqlite3.Connection | None = None
+
+    # -------------------------
+    # Połączenie z bazą
+    # -------------------------
+    def connect(self):
+        """Nawiązuje połączenie z bazą i tworzy tabele, jeśli ich nie ma."""
+        self.conn = sqlite3.connect(self.db_path)
+        self.conn.row_factory = sqlite3.Row
+        self._create_tables()
+
+    def disconnect(self):
+        if self.conn:
+            self.conn.close()
+            self.conn = None
+
+    # -------------------------
+    # Tworzenie tabel
+    # -------------------------
+    def _create_tables(self):     
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+
+        cur.execute(
+            """
+            CREATE TABLE IF NOT EXISTS colors (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT UNIQUE NOT NULL,
+                icon_path TEXT NOT NULL
+            )
+            """
+        )
+
+        cur.execute(
+            """
+            CREATE TABLE IF NOT EXISTS media (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                color_id INTEGER NOT NULL,
+                media_path TEXT NOT NULL,
+                file_type TEXT CHECK(file_type IN ('photo','video')),
+                timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY(color_id) REFERENCES colors(id) ON DELETE CASCADE
+            )
+            """
+        )
+
+        self.conn.commit()
+
+    # -------------------------
+    # Operacje na kolorach
+    # -------------------------
+    def add_color(self, name: str, icon_path: str):
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute(
+            "INSERT OR IGNORE INTO colors (name, icon_path) VALUES (?, ?)",
+            (name, icon_path),
+        )
+        self.conn.commit()
+
+    def get_color_id(self, name: str) -> int | None:
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("SELECT id FROM colors WHERE name = ?", (name,))
+        row = cur.fetchone()
+        return row["id"] if row else None
+
+    def get_all_colors(self) -> list[dict]:
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("SELECT * FROM colors ORDER BY name")
+        rows = cur.fetchall()
+        return [dict(r) for r in rows]
+
+    def update_color_name(self, old_name: str, new_name: str):
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("UPDATE colors SET name = ? WHERE name = ?", (new_name, old_name))
+        self.conn.commit()
+
+    def update_color_icon(self, name: str, icon_path: str):
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("UPDATE colors SET icon_path = ? WHERE name = ?", (icon_path, name))
+        self.conn.commit()
+
+    def delete_color(self, name: str):
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("DELETE FROM colors WHERE name = ?", (name,))
+        self.conn.commit()
+
+    # -------------------------
+    # Operacje na plikach
+    # -------------------------
+    def add_media(self, color_id: int, media_path: str, file_type: str, timestamp: str | None = None):
+        if timestamp is None:
+            timestamp = datetime.now().isoformat()
+
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute(
+            "INSERT INTO media (color_id, media_path, file_type, timestamp) VALUES (?, ?, ?, ?)",
+            (color_id, media_path, file_type, timestamp),
+        )
+        self.conn.commit()
+
+    def get_media(self, media_id: int) -> dict | None:
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("SELECT * FROM media WHERE id = ?", (media_id,))
+        row = cur.fetchone()
+        return dict(row) if row else None
+
+    def get_media_for_color(self, color_id: int) -> list[dict]:
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("SELECT * FROM media WHERE color_id = ? ORDER BY timestamp DESC", (color_id,))
+        rows = cur.fetchall()
+        return [dict(r) for r in rows]
+
+    def delete_media(self, color_id: int, media_path: str):
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("DELETE FROM media WHERE color_id = ? AND media_path = ?", (color_id, media_path))
+        self.conn.commit()
+
+    def delete_all_media_for_color(self, color_id: int):
+        if self.conn is None:
+            raise RuntimeError("Database not connected")
+        cur = self.conn.cursor()
+        cur.execute("DELETE FROM media WHERE color_id = ?", (color_id,))
+        self.conn.commit()

core/media.py

@@ -0,0 +1,95 @@
+from pathlib import Path
+import shutil
+from core.database import DatabaseManager
+
+MEDIA_DIR = Path("media")
+DEFAULT_ICON = Path("media/default_icon.jpg")
+
+class MediaRepository:
+    def __init__(self, db: DatabaseManager):
+        self.db = db
+
+    def sync_media(self):
+        disk_colors = {d.name for d in MEDIA_DIR.iterdir() if d.is_dir()}
+        db_colors = {c["name"] for c in self.db.get_all_colors()}
+
+        # usuwanie brakujących kolorów
+        for missing in db_colors - disk_colors:
+            self.db.delete_color(missing)
+
+        # dodawanie nowych kolorów
+        for color in disk_colors - db_colors:
+            # has_icon = (MEDIA_DIR / color / "icon.jpg").exists()
+            # self.db.add_color(color, has_icon=has_icon)
+            # icon = MEDIA_DIR / color / "icon.jpg"
+            self.add_color(color)
+
+        # sprawdzanie plików dla każdego koloru
+        for color in disk_colors:
+            color_id = self.db.get_color_id(color)
+            if color_id is None:
+                continue
+            color_dir = MEDIA_DIR / color
+            icon_file = color_dir / "icon.jpg"
+            self.db.update_color_icon(color, icon_file.as_posix() if icon_file.exists() else DEFAULT_ICON.as_posix())
+
+            disk_files = {f.as_posix() for f in color_dir.iterdir() if f.is_file() and f.name != "icon.jpg"}
+            db_files = {m["media_path"] for m in self.db.get_media_for_color(color_id)}
+
+            # usuń brakujące
+            for missing in db_files - disk_files:
+                self.db.delete_media(color_id, missing)
+
+            # dodaj nowe
+            for new in disk_files - db_files:
+                ftype = "photo" if Path(new).suffix.lower() in [".jpg", ".png"] else "video"
+                self.db.add_media(color_id, new, ftype)
+
+    def add_color(self, name: str, icon_path: Path | None = None):
+        color_dir = MEDIA_DIR / name
+        color_dir.mkdir(parents=True, exist_ok=True)
+
+        icon_file = color_dir / "icon.jpg"
+        if icon_path and icon_path.exists():
+            shutil.copy(icon_path, icon_file)
+
+        self.db.add_color(name, icon_file.as_posix() if icon_file.exists() else DEFAULT_ICON.as_posix())
+
+    def remove_color(self, name: str):
+        if (MEDIA_DIR / name).exists():
+            shutil.rmtree(MEDIA_DIR / name)
+        self.db.delete_color(name)
+
+    def update_color(self, old_name: str, new_name: str, icon_path: Path | None = None):
+        old_dir = MEDIA_DIR / old_name
+        new_dir = MEDIA_DIR / new_name
+        icon_file = new_dir / "icon.jpg"
+
+        if old_dir.exists():
+            old_dir.rename(new_dir)
+
+        if icon_path and icon_path.exists():
+            shutil.copy(icon_path, icon_file)
+  
+        self.db.update_color_name(old_name, new_name)
+        self.db.update_color_icon(new_name, icon_file.as_posix() if icon_file.exists() else DEFAULT_ICON.as_posix())
+
+    def add_media(self, color: str, file_path: Path):
+        target_dir = MEDIA_DIR / color
+        target_dir.mkdir(exist_ok=True)
+        target_file = target_dir / file_path.name
+        shutil.copy(file_path, target_file)
+
+        ftype = "photo" if file_path.suffix.lower() in [".jpg", ".png"] else "video"
+        color_id = self.db.get_color_id(color)
+        if color_id is not None:
+            self.db.add_media(color_id, target_file.as_posix(), ftype)
+
+    def remove_media(self, color: str, file_path: Path):
+        # file_path = MEDIA_DIR / color / filename
+        if file_path.exists():
+            file_path.unlink()
+
+        color_id = self.db.get_color_id(color)
+        if color_id is not None:
+            self.db.delete_media(color_id, file_path.as_posix())

main.py

@@ -0,0 +1,23 @@
+import sys
+from PySide6.QtWidgets import QApplication
+
+from ui.main_palette import set_dark_theme
+from ui.main_window import MainWindow
+from controllers.main_controller import MainController
+
+
+
+def main():
+    app = QApplication(sys.argv)
+    set_dark_theme(app)
+    # app.setStyle("Fusion")
+    window = MainWindow()
+    controller = MainController(window)
+    controller.load_colors()
+
+    app.aboutToQuit.connect(controller.shutdown)
+    window.show()
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,6 @@
+numpy==2.2.6
+opencv-python==4.12.0.88
+PySide6==6.9.2
+PySide6_Addons==6.9.2
+PySide6_Essentials==6.9.2
+shiboken6==6.9.2

ui/main_palette.py

@@ -0,0 +1,48 @@
+import sys
+from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import QPalette, QColor
+from PySide6.QtCore import Qt
+
+def set_dark_theme(app: QApplication):
+    """Definiuje i stosuje ciemną paletę kolorów do aplikacji."""
+    
+    # 1. Upewnij się, że styl jest ustawiony na "Fusion"
+    app.setStyle('Fusion')
+    
+    # 2. Definicja kolorów dla ciemnego motywu
+    palette = QPalette()
+    
+    # Kolory tła
+    DARK_GRAY = QColor(45, 45, 45)    # Ogólne tło okien i widżetów (Base, Window)
+    LIGHT_GRAY = QColor(53, 53, 53)   # Tło elementów, np. toolbara, menu (Window)
+    VERY_DARK_GRAY = QColor(32, 32, 32) # Kolor tła dla kontrolek (Button)
+    
+    # Kolory tekstu i obramowań
+    WHITE = QColor(200, 200, 200)    # Główny kolor tekstu (Text, WindowText)
+    HIGHLIGHT = QColor(66, 135, 245) # Kolor podświetlenia (Highlight)
+
+    # Ustawienie głównej palety
+    # palette.setColor(QPalette.ColorRole.Window, LIGHT_GRAY)
+    palette.setColor(QPalette.ColorRole.Window, VERY_DARK_GRAY)
+    palette.setColor(QPalette.ColorRole.WindowText, WHITE)
+    palette.setColor(QPalette.ColorRole.Base, DARK_GRAY)
+    palette.setColor(QPalette.ColorRole.AlternateBase, LIGHT_GRAY)
+    palette.setColor(QPalette.ColorRole.ToolTipBase, WHITE)
+    palette.setColor(QPalette.ColorRole.ToolTipText, WHITE)
+    palette.setColor(QPalette.ColorRole.Text, WHITE)
+    palette.setColor(QPalette.ColorRole.Button, VERY_DARK_GRAY)
+    palette.setColor(QPalette.ColorRole.ButtonText, WHITE)
+    palette.setColor(QPalette.ColorRole.BrightText, Qt.GlobalColor.red)
+    palette.setColor(QPalette.ColorRole.Link, QColor(42, 130, 218))
+    palette.setColor(QPalette.ColorRole.PlaceholderText, QColor(150, 150, 150))
+    
+    # Kolory zaznaczenia/interakcji
+    palette.setColor(QPalette.ColorRole.Highlight, HIGHLIGHT)
+    palette.setColor(QPalette.ColorRole.HighlightedText, Qt.GlobalColor.black)
+    
+    # Kontrolki wyłączone (Disabled)
+    # palette.setColor(QPalette.ColorRole.Disabled, QPalette.ColorGroup.Active, QPalette.ColorRole.Text, QColor(127, 127, 127))
+    # palette.setColor(QPalette.ColorRole.Disabled, QPalette.ColorGroup.Active, QPalette.ColorRole.ButtonText, QColor(127, 127, 127))
+
+    # 3. Zastosowanie palety do aplikacji
+    app.setPalette(palette)

ui/main_window.py

@@ -0,0 +1,66 @@
+import sys
+from PySide6.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QPushButton, QLabel, QSplitter, QStackedWidget, QLineEdit
+)
+from PySide6.QtCore import Qt, Slot
+from PySide6.QtGui import QPalette, QColor
+
+from ui.widgets.placeholder_widget import PlaceholderWidget
+from ui.widgets.color_list_widget import ColorListWidget
+from ui.widgets.thumbnail_list_widget import ThumbnailListWidget
+from ui.widgets.split_view_widget import SplitView
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Mayo Stain Helper")
+        self.resize(1920, 1080)
+        self.setup_ui()
+
+    def setup_ui(self):
+        # Central widget and main layout
+        central_widget = QWidget()
+        main_layout = QHBoxLayout(central_widget)
+        self.setCentralWidget(central_widget)
+
+        self.preview_widget = SplitView()
+
+        self.thumbnail_widget = ThumbnailListWidget()
+        self.thumbnail_widget.setFixedWidth(200)
+
+        self.control_widget = QWidget()
+        self.control_widget.setFixedWidth(300)
+
+        main_layout.addWidget(self.preview_widget)
+        main_layout.addWidget(self.thumbnail_widget)
+        main_layout.addWidget(self.control_widget)
+
+        control_layout = QVBoxLayout(self.control_widget)
+        control_layout.setContentsMargins(0, 0, 0, 0)
+
+        histogram_view = PlaceholderWidget("Histogram View", "#FF5733")
+        histogram_view.setFixedHeight(200)
+
+        self.color_list_widget = ColorListWidget(self.control_widget)
+
+        self.record_button = QPushButton("Nagraj Wideo")
+        self.record_button.setMinimumHeight(40)
+        self.record_button.setStyleSheet("font-size: 12pt;")
+
+        self.photo_button = QPushButton("Zrób zdjęcie")
+        self.photo_button.setMinimumHeight(40)
+        self.photo_button.setStyleSheet("font-size: 12pt;")
+        
+        control_layout.addWidget(histogram_view)
+        control_layout.addWidget(self.color_list_widget)
+        control_layout.addWidget(self.record_button)
+        control_layout.addWidget(self.photo_button)
+
+
+
+
+
+
+         
+

ui/widgets/color_list_widget.py

@@ -0,0 +1,136 @@
+from PySide6.QtWidgets import (
+    QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLineEdit, QListView,
+    QAbstractItemView, QComboBox, QLabel, QStyledItemDelegate, QStyleOptionButton, QStyle,
+)
+from PySide6.QtGui import QPixmap, QIcon, QColor, QStandardItemModel, QStandardItem, QPainter, QCursor
+from PySide6.QtCore import Qt, QSortFilterProxyModel, QSize, QRect, Signal, QModelIndex, QEvent, QItemSelectionModel
+import sys
+
+
+class FilterProxy(QSortFilterProxyModel):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.search_text = ""
+
+    def setSearchText(self, text: str):
+        self.search_text = text
+        self.invalidateFilter()
+
+    def filterAcceptsRow(self, source_row, source_parent):
+        if not self.search_text:
+            return True
+        model = self.sourceModel()
+        index = model.index(source_row, 0, source_parent)
+        name = model.data(index, Qt.ItemDataRole.DisplayRole)
+        return self.search_text.lower() in name.lower()
+
+
+class EditButtonDelegate(QStyledItemDelegate):
+    editClicked = Signal(QModelIndex)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.button_clicked_row = None
+        self.margin = 8
+
+    def paint(self, painter, option, index):
+        super().paint(painter, option, index)
+
+        if option.state & QStyle.StateFlag.State_MouseOver:
+            button = QStyleOptionButton()
+            button.rect = QRect(option.rect.right() - 60, option.rect.top() + self.margin , 60, option.rect.height() - self.margin * 2) # type: ignore
+            button.text = "EDYTUJ" # type: ignore
+            QApplication.style().drawControl(QStyle.ControlElement.CE_PushButton, button, painter)
+
+
+    def editorEvent(self, event, model, option, index):
+        button_rect = QRect(option.rect.right() - 60, option.rect.top() + self.margin , 60, option.rect.height() - self.margin * 2)
+
+        if event.type() == QEvent.Type.MouseButtonRelease:
+            # button_rect = QRect(option.rect.right() - 60, option.rect.top(), 60, option.rect.height())
+            if button_rect.contains(event.pos()):
+                self.button_clicked_row = index.row()
+                self.editClicked.emit(index)
+                return True
+        return super().editorEvent(event, model, option, index)
+
+
+class ColorListWidget(QWidget):
+    editColor = Signal(str)
+    colorSelected = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.colors = None
+
+        layout = QVBoxLayout(self)
+
+        self.filter_edit = QLineEdit()
+        self.filter_edit.setPlaceholderText("Szukaj po nazwie koloru...")
+        self.filter_edit.setMinimumHeight(32)
+        self.filter_edit.setStyleSheet("font-size: 12pt;")
+
+        edit_clear = self.filter_edit.addAction(QIcon("media/EditClear.svg"), QLineEdit.ActionPosition.TrailingPosition)
+        edit_clear.triggered.connect(lambda: self.filter_edit.clear())
+
+        layout.addWidget(self.filter_edit)
+
+        self.model = QStandardItemModel(self)
+
+        self.proxy_model = FilterProxy(self)
+        self.proxy_model.setSourceModel(self.model)
+
+        self.list_view = QListView()
+        self.list_view.setModel(self.proxy_model)
+        
+        self.list_view.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.list_view.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self.list_view.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectItems)
+        self.list_view.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.list_view.setUniformItemSizes(True)
+        self.list_view.setSpacing(2)
+        self.list_view.setIconSize(QSize(36, 36))
+        self.list_view.setMouseTracking(True)
+        
+        layout.addWidget(self.list_view)
+
+        self.delegate = EditButtonDelegate(self.list_view)
+        self.delegate.editClicked.connect(self.on_edit_clicked)
+        self.list_view.setItemDelegate(self.delegate)
+
+        self.filter_edit.textChanged.connect(self.on_filter_changed)
+        self.list_view.clicked.connect(self.on_item_clicked)
+
+    def on_filter_changed(self, text: str):
+        self.proxy_model.setSearchText(text)
+        self.list_view.clearSelection()
+
+    def set_colors(self, db_colors: list[dict]):
+        self.model.clear()
+        for color in db_colors:
+            item = QStandardItem( color['name'])
+            item.setIcon(QIcon(color['icon_path']))
+            self.model.appendRow(item)
+
+    def on_item_clicked(self, index):
+        if self.delegate.button_clicked_row == index.row():
+            self.delegate.button_clicked_row = None
+            return
+        
+        self.list_view.selectionModel().select(index, QItemSelectionModel.SelectionFlag.ClearAndSelect)
+        source_index = self.proxy_model.mapToSource(index)
+        item = self.model.itemFromIndex(source_index)
+        if item:
+            line = item.text()
+            # print(f"Kliknięto kolor: {line}")
+            self.colorSelected.emit(line)
+            return line
+        
+    def on_edit_clicked(self, index):
+        source_index = self.proxy_model.mapToSource(index)
+        # print("Edit:", self.model.itemFromIndex(source_index).text())
+        item = self.model.itemFromIndex(source_index)
+        if item:
+            line = item.text()
+            # print(f"Edycja koloru: {line}")
+            self.editColor.emit(line)

ui/widgets/placeholder_widget.py

@@ -0,0 +1,35 @@
+from PySide6.QtWidgets import QWidget, QLabel, QVBoxLayout
+from PySide6.QtGui import QPalette, QColor
+from PySide6.QtCore import Qt
+
+class PlaceholderWidget(QWidget):
+    """A custom widget to display a colored background with centered text."""
+    def __init__(self, text: str, color: str, parent=None):
+        super().__init__(parent)
+        self.setAutoFillBackground(True)
+        self.set_color(color)
+
+        self.label = QLabel(text)
+        self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        
+        font = self.label.font()
+        font.setPointSize(24)
+        self.label.setFont(font)
+        self.label.setWordWrap(True)
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.label)
+        self.setLayout(layout)
+
+    def set_text(self, text: str):
+        self.label.setText(text)
+
+    def set_color(self, color: str):
+        palette = self.palette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(color))
+        self.setPalette(palette)
+
+    def set_text_color(self, color: str):
+        palette = self.label.palette()
+        palette.setColor(QPalette.ColorRole.WindowText, QColor(color))
+        self.label.setPalette(palette)

ui/widgets/split_view_widget.py

@@ -0,0 +1,164 @@
+from PySide6.QtWidgets import QGraphicsView, QGraphicsScene, QGraphicsPixmapItem, QApplication, QMainWindow, QWidget, QVBoxLayout, QSplitter, QStackedWidget, QPushButton, QLabel
+from PySide6.QtGui import QPixmap, QWheelEvent, QPainter, QBrush, QColor
+from PySide6.QtCore import Qt
+import sys
+from ui.widgets.placeholder_widget import PlaceholderWidget
+
+class ZoomableImageView(QGraphicsView):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        # Scena i element obrazu
+        self._scene = QGraphicsScene(self)
+        self.setScene(self._scene)
+        self._scene.setBackgroundBrush(QBrush(QColor(20, 20, 20)))  # ciemne tło
+
+        self._pixmap_item = QGraphicsPixmapItem()
+        self._scene.addItem(self._pixmap_item)
+
+        # Ustawienia widoku
+        self.setDragMode(QGraphicsView.DragMode.ScrollHandDrag)  # przesuwanie myszą
+        self.setRenderHint(QPainter.RenderHint.Antialiasing)
+        self.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+
+        # Wyłączenie suwaków
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        # Parametry zoomu
+        self._zoom_factor = 1.25
+        self._current_scale = 1.0
+
+    def set_image(self, pixmap: QPixmap):
+        # pixmap = QPixmap(image_path)
+        self._pixmap_item.setPixmap(pixmap)
+        self._scene.setSceneRect(pixmap.rect())
+        # self.reset_transform()
+
+    def reset_transform(self):
+        """Resetuje skalowanie i ustawia 1:1"""
+        self._current_scale = 1.0
+        self.setTransform(self.transform().fromScale(1, 1))
+
+    def wheelEvent(self, event: QWheelEvent):
+        """Zoom kółkiem myszy"""
+        if event.modifiers() & Qt.KeyboardModifier.ControlModifier:  # zoom tylko z CTRL
+            if event.angleDelta().y() > 0:
+                zoom = self._zoom_factor
+            else:
+                zoom = 1 / self._zoom_factor
+
+            self._current_scale *= zoom
+            self.scale(zoom, zoom)
+        else:
+            return
+            super().wheelEvent(event)  # normalne przewijanie
+
+class CameraPlaceholder(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.setAutoFillBackground(True)
+        self.setStyleSheet("background-color: #141414;")
+
+        layout = QVBoxLayout(self)
+        layout.setSpacing(20)
+
+        self.camera_start_btn = QPushButton("Start Camera")
+        self.camera_start_btn.setFixedSize(200, 50)
+        style_sheet = """
+                        QPushButton {
+                /* --- Styl podstawowy --- */
+                background-color: transparent;
+                border: 2px solid #CECECE; /* Grubość, styl i kolor obramowania */
+                border-radius: 25px; /* Kluczowa właściwość do zaokrąglenia rogów! */
+                color: #CECECE;
+                padding: 10px 20px; /* Wewnętrzny margines */
+                font-size: 16px;
+            }
+
+            QPushButton:hover {
+                /* --- Styl po najechaniu myszką --- */
+                color: #F0F0F0;
+                border: 2px solid #F0F0F0;
+            }
+
+            QPushButton:pressed {
+                /* --- Styl po naciśnięciu --- */
+                background-color: #e0e0e0; /* Ciemniejsze tło w momencie kliknięcia */
+                border: 2px solid #e0e0e0; /* Zmiana koloru ramki dla sygnalizacji akcji */
+            }
+        """
+        self.camera_start_btn.setStyleSheet(style_sheet)
+
+        self.info_label = QLabel("Kliknij, aby uruchomić kamerę")
+        self.info_label.setStyleSheet("background-color: transparent; color: #CECECE; font-size: 18px;")
+        self.info_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        layout.addStretch()
+        layout.addWidget(self.camera_start_btn, alignment=Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.info_label)
+        layout.addStretch()
+        self.setLayout(layout)
+
+    def set_info_text(self, text: str):
+        self.info_label.setText(text)
+
+class SplitView(QSplitter):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        print("Inicjalizacja SplitView2")
+        self.setOrientation(Qt.Orientation.Vertical)
+
+        self.widget_start = CameraPlaceholder()
+        self.widget_live = ZoomableImageView()
+        # self.widget_live = PlaceholderWidget("Camera View", "#750466")
+        self.widget_ref = ZoomableImageView()
+        # self.widget_ref = PlaceholderWidget("Image View", "#007981")
+
+        self.stack = QStackedWidget()
+        self.stack.addWidget(self.widget_start)
+        self.stack.addWidget(self.widget_live)
+        self.stack.setCurrentWidget(self.widget_start)
+
+        self.addWidget(self.stack)
+        self.addWidget(self.widget_ref)
+
+        self.setSizes([self.height(), 0])
+
+        pixmap = QPixmap("media/empty_guitar_h.jpg")
+        # pixmap.fill(Qt.GlobalColor.lightGray)
+        self.widget_live.set_image(pixmap)
+
+    def toggle_orientation(self):
+        if self.orientation() == Qt.Orientation.Vertical:
+            self.setOrientation(Qt.Orientation.Horizontal)
+            self.setSizes([self.width()//2, self.width()//2])
+        else:
+            self.setOrientation(Qt.Orientation.Vertical)
+            self.setSizes([self.height()//2, self.height()//2])
+    
+    # def set_live_image(self, path_image: str):
+    #     """Ustawienie obrazu na żywo"""
+    #     pixmap = QPixmap(path_image)
+    #     self.widget_live.set_image(pixmap)
+
+    def set_live_image(self,  pixmap: QPixmap):
+        """Ustawienie obrazu na żywo"""
+        self.widget_live.set_image(pixmap)
+        if self.stack.currentWidget() != self.widget_live:
+            self.stack.setCurrentWidget(self.widget_live)
+
+    def set_reference_image(self, path_image: str):
+        """Ustawienie obrazu referencyjnego"""
+        pixmap = QPixmap(path_image)
+        self.widget_ref.set_image(pixmap)
+
+    def toglle_live_view(self):
+        """Przełączanie widoku na żywo"""
+        if self.stack.currentWidget() == self.widget_start:
+            self.stack.setCurrentWidget(self.widget_live)
+        else:
+            self.stack.setCurrentWidget(self.widget_start)
+
+    
+

ui/widgets/thumbnail_list_widget.py

@@ -0,0 +1,89 @@
+from PySide6.QtWidgets import (
+    QApplication, QWidget, QVBoxLayout, QListWidget, QListWidgetItem,
+    QLabel, QHBoxLayout
+)
+from PySide6.QtGui import QPixmap, QIcon
+from PySide6.QtCore import Qt, QSize, Signal
+import sys
+
+def make_thumbnail(image_path: str, size: QSize) -> QPixmap:
+    pixmap = QPixmap(image_path)
+
+    if pixmap.isNull():
+        pixmap = QPixmap("media/empty_guitar_h.jpg")  # pusta miniatura, gdy nie uda się wczytać
+
+    # dopasuj tak, aby całkowicie wypełnić prostokąt (cover)
+    scaled = pixmap.scaled(
+        size,
+        Qt.AspectRatioMode.KeepAspectRatioByExpanding,
+        Qt.TransformationMode.SmoothTransformation
+    )
+
+    # wytnij nadmiar, żeby miało dokładnie żądany rozmiar
+    x = (scaled.width() - size.width()) // 2
+    y = (scaled.height() - size.height()) // 2
+    cropped = scaled.copy(x, y, size.width(), size.height())
+
+    return cropped
+
+
+class ThumbnailItemWidget(QWidget):
+    def __init__(self, image_path: str, text: str = "", parent=None):
+        super().__init__(parent)
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(6, 6, 6, 6)
+        layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        # miniatura
+        pixmap = make_thumbnail(image_path, QSize(180, 160))
+        self.icon_label = QLabel()
+        self.icon_label.setPixmap(pixmap)
+
+        # podpis
+        self.text_label = QLabel(text)
+        self.text_label.setStyleSheet("font-size: 12pt;")
+        self.text_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        # ustawiamy pionowy layout dla ikony i tekstu
+        vbox = QVBoxLayout()
+        vbox.setContentsMargins(0, 0, 0, 0)
+        vbox.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        vbox.addWidget(self.icon_label)
+        vbox.addWidget(self.text_label)
+
+        layout.addLayout(vbox)
+
+
+class ThumbnailListWidget(QWidget):
+    selectedThumbnail = Signal(int)  # sygnał z ID wybranego elementu
+
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self.list_widget = QListWidget()
+        # self.list_widget.setIconSize(QSize(100, 100))
+        self.list_widget.setSpacing(2)
+
+        layout.addWidget(self.list_widget)
+
+        self.list_widget.itemPressed.connect(self.on_item_pressed)
+
+    def add_thumbnail(self, image_path: str, text: str, id: int):
+        item = QListWidgetItem()
+        item.setData(Qt.ItemDataRole.UserRole, id)
+        item.setSizeHint(QSize(192, 192))  # rozmiar „wiersza”
+
+        print(f"Adding thumbnail: {image_path} with text: {text}")
+        widget = ThumbnailItemWidget(image_path, text)
+        self.list_widget.addItem(item)
+        self.list_widget.setItemWidget(item, widget)
+
+    def on_item_pressed(self, item: QListWidgetItem):
+        row = self.list_widget.row(item)
+        id = item.data(Qt.ItemDataRole.UserRole)
+        print(f"Kliknięto miniaturę w wierszu: {row}, obiekt ID: {id}")
+        self.selectedThumbnail.emit(id)
+