Merge pull request #69 from DiamondLightSource/245-MianWindow

Refactor main window

Author: UrszulaNeuman

dls_barcode/gui/barcode_table.py

@@ -27,8 +27,8 @@ def _init_ui(self):
 
         # Create barcode table - lists all the barcodes in a record
         self._table = QtGui.QTableWidget()
-        self._table.setFixedWidth(110)
-        self._table.setFixedHeight(600)
+        self._table.setMinimumWidth(110)
+        self._table.setMinimumHeight(600)
         self._table.setColumnCount(1)
         self._table.setRowCount(10)
         self._table.setHorizontalHeaderLabels(['Barcode'])

dls_barcode/gui/image_frame.py

@@ -16,9 +16,9 @@ def __init__(self, title):
     def _init_ui(self):
         # Image frame - displays image of the currently selected scan record
         self._frame = QLabel()
-        self._frame.setStyleSheet("background-color: black; color: red; font-size: 30pt; text-align: center")
-        self._frame.setFixedWidth(500)
-        self._frame.setFixedHeight(500)
+        self._frame.setStyleSheet("background-color: white; color: red; font-size: 30pt; text-align: center")
+        self._frame.setMinimumWidth(500)
+        self._frame.setMinimumHeight(500)
         self._frame.setAlignment(Qt.AlignCenter)
 
         vbox = QVBoxLayout()

dls_barcode/gui/main_window.py

@@ -1,69 +1,39 @@
-import multiprocessing
-import queue
-import time
+import sys
+from PyQt4 import QtGui
 
-from PyQt4 import QtGui, QtCore
+from dls_barcode.config import BarcodeConfigDialog
 
-from dls_barcode.config import BarcodeConfig, BarcodeConfigDialog
-from dls_barcode.camera import CameraScanner, CameraSwitch, NoNewBarcodeMessage, ScanErrorMessage
 from dls_barcode.gui.scan_button import ScanButton
-from dls_util import Beeper
-from dls_util.file import FileManager
+
 from .barcode_table import BarcodeTable
 from .image_frame import ImageFrame
 from .record_table import ScanRecordTable
 from .message_box import MessageBox
 from .message_factory import MessageFactory
 from .menu_bar import MenuBar
 
-RESULT_TIMER_PERIOD = 1000  # ms
-VIEW_TIMER_PERIOD = 1  # ms
-MESSAGE_TIMER_PERIOD = 1  # ms
-
 
 class DiamondBarcodeMainWindow(QtGui.QMainWindow):
     """ Main GUI window for the Barcode Scanner App.
     """
-    def __init__(self, config_file, version):
+
+    def __init__(self, config, version):
         super(DiamondBarcodeMainWindow, self).__init__()
 
-        self._config = BarcodeConfig(config_file, FileManager())
+        self._config = config
         self._version = version
+        self._cleanup = None
+        self._initialise_scanner = None
+        self._camera_capture_alive = None
 
         # UI elements
         self._record_table = None
         self._barcode_table = None
         self._image_frame = None
         self._scan_button = None
 
-        # Scan elements
-        self._camera_scanner = None
-        self._camera_switch = None
-
         self._init_ui()
 
-        # Queue that holds new results generated in continuous scanning mode
-        self._result_queue = multiprocessing.Queue()
-        self._view_queue = multiprocessing.Queue()
-        self._message_queue = multiprocessing.Queue()
-        self._initialise_scanner()
-        self._reset_msg_timer()
-
-        # Timer that controls how often new scan results are looked for
-        self._result_timer = QtCore.QTimer()
-        self._result_timer.timeout.connect(self._read_result_queue)
-        self._result_timer.start(RESULT_TIMER_PERIOD)
-
-        self._view_timer = QtCore.QTimer()
-        self._view_timer.timeout.connect(self._read_view_queue)
-        self._view_timer.start(VIEW_TIMER_PERIOD)
-
-        self._message_timer = QtCore.QTimer()
-        self._message_timer.timeout.connect(self._read_message_queue)
-        self._message_timer.start(MESSAGE_TIMER_PERIOD)
-
-        self._restart_live_capture_from_side()
-
     def _init_ui(self):
         """ Create the basic elements of the user interface.
         """
@@ -73,19 +43,19 @@ def _init_ui(self):
         self.setWindowTitle('Diamond Puck Barcode Scanner')
         self.setWindowIcon(self._window_icon)
 
-        self._menu_bar = MenuBar(self.menuBar(), self._version, self._cleanup, self._on_options_action_clicked,self._on_about_action_clicked)
+        self._menu_bar = MenuBar(self.menuBar(), self._version)
 
         # Barcode table - lists all the barcodes in a record
         self._barcode_table = BarcodeTable(self._config)
 
         # Scan button - start/stop scan
-        self._scan_button = ScanButton('Start/stop scan', self._on_scan_action_clicked)
+        self._scan_button = ScanButton('Start/stop scan')
 
         # Image frame - displays image of the currently selected scan record
         self._image_frame = ImageFrame("Plate Image")
 
         # Scan record table - lists all the records in the store
-        self._record_table = ScanRecordTable(self._barcode_table, self._image_frame, self._config, self._to_run_on_table_clicked)
+        self._record_table = ScanRecordTable(self._barcode_table, self._image_frame, self._config)
 
         # Message display
         self._message_box = MessageBox()
@@ -116,18 +86,28 @@ def _init_ui(self):
 
         self.show()
 
+    def set_actions_triger(self, cleanup, initialise_scanner, camera_capture_alive):
+        self._cleanup = cleanup
+        self._initialise_scanner = initialise_scanner
+        self._camera_capture_alive = camera_capture_alive
+        self._scan_button.click_action(self._on_scan_action_clicked)
+        self._menu_bar.exit_action_triggered(self._cleanup)
+        self._menu_bar.about_action_trigerred(self._on_about_action_clicked)
+        self._menu_bar.optiones_action_triggered(self._on_options_action_clicked)
+        self._record_table.cell_pressed_action_triggered(self._to_run_on_table_clicked)
+
     def _to_run_on_table_clicked(self):
         self._cleanup()
         self._scan_button.setStartLayout()
 
     def _on_about_action_clicked(self):
         QtGui.QMessageBox.about(self, 'About', "Version: " + self._version)
 
+
     def _on_scan_action_clicked(self):
         print("MAIN: Scan menu clicked")
         if not self._camera_capture_alive():
             self._initialise_scanner()
-            self._restart_live_capture_from_side()
             self._scan_button.setDelayedStopLayout()
         else:
             self._cleanup()
@@ -144,122 +124,20 @@ def closeEvent(self, event):
         self._cleanup()
         event.accept()
 
-    def _cleanup(self):
-        if not self._camera_capture_alive():
-            return
-
-        self._camera_scanner.kill()
-        self._camera_scanner = None
-        self._camera_switch = None
-
-    def _initialise_scanner(self):
-        self._camera_scanner = CameraScanner(self._result_queue, self._view_queue, self._message_queue, self._config)
-        self._camera_switch = CameraSwitch(self._camera_scanner, self._config.top_camera_timeout)
+    def displayScanCompleteMessage(self):
+        self._message_box.display(MessageFactory.scan_completed_message())
 
-    def _camera_capture_alive(self):
-        return self._camera_scanner is not None and self._camera_switch is not None
+    def displayScanErrorMessage(self, scanner_msg):
+        self._message_box.display(MessageFactory.from_scanner_message(scanner_msg))
 
-    def _read_view_queue(self):
-        if self._view_queue.empty():
-            return
-
-        try:
-            image = self._view_queue.get(False)
-        except queue.Empty:
-            return
+    def displayScanTimeoutMessage(self):
+        self._message_box.display(MessageFactory.scan_timeout_message())
 
+    def displayPuckImage(self, image):
         self._image_frame.display_puck_image(image)
 
-    def _read_message_queue(self):
-        if self._message_queue.empty():
-            return
-
-        try:
-            scanner_msg = self._message_queue.get(False)
-        except queue.Empty:
-            return
-
-        if self._camera_switch.is_side():
-            if not self._msg_timer_is_running():
-                # The result queue is read at a slower rate - use a timer to give it time to process a new barcode
-                self._start_msg_timer()
-            elif self._has_msg_timer_timeout() and isinstance(scanner_msg, NoNewBarcodeMessage):
-                    self._message_box.display(MessageFactory.scan_completed_message())
-            elif isinstance(scanner_msg, ScanErrorMessage):
-                    self._message_box.display(MessageFactory.from_scanner_message(scanner_msg))
-                    self._reset_msg_timer()
-        else:
-            self._reset_msg_timer()
-
-    def _reset_msg_timer(self):
-        self._record_msg_timer = None
-
-    def _start_msg_timer(self):
-        self._record_msg_timer = time.time()
-
-    def _msg_timer_is_running(self):
-        return self._record_msg_timer is not None
-
-    def _has_msg_timer_timeout(self):
-        timeout =2 * RESULT_TIMER_PERIOD / 1000
-        return self._msg_timer_is_running() and time.time() - self._record_msg_timer > timeout
-
-    def _read_result_queue(self):
-        """ Called every second; read any new results from the scan results queue, store them and display them.
-        """
-        if not self._camera_capture_alive():
-            return
-
-        if self._camera_switch.is_side():
-            self._read_side_scan()
-        else:
-            self._read_top_scan()
-
-    def _read_side_scan(self):
-        if self._result_queue.empty():
-            return
-
-        # Get the result
-        plate, holder_image = self._result_queue.get(False)
-        if not plate.is_full_valid():
-            return
-
-        # Barcode successfully read
-        Beeper.beep()
-        print("MAIN: puck barcode recorded")
-        holder_barcode = plate.barcodes()[0]
-        if not self._record_table.is_latest_holder_barcode(holder_barcode):
-            self._latest_holder_barcode = holder_barcode
-            self._latest_holder_image = holder_image
-            self._restart_live_capture_from_top()
-
-    def _read_top_scan(self):
-        if self._result_queue.empty():
-            if self._camera_switch.is_top_scan_timeout():
-                self._message_box.display(MessageFactory.scan_timeout_message())
-                print("\n*** Scan timeout ***")
-                self._restart_live_capture_from_side()
-            return
-
-        # Get the result
-        plate, pins_image = self._result_queue.get(False)
-
-        # Add new record to the table - side is the _latest_holder_barcode read first, top is the plate
-        self._record_table.add_record_frame(self._latest_holder_barcode, plate, self._latest_holder_image, pins_image)
-        if not plate.is_full_valid():
-            return
-
-        # Barcodes successfully read
-        Beeper.beep()
-        print("Scan Completed",  self._camera_switch.get_scan_time())
-        self._restart_live_capture_from_side()
-
-    def _restart_live_capture_from_top(self):
-        self._camera_switch.restart_live_capture_from_top()
-
-    def _restart_live_capture_from_side(self):
-        self._reset_msg_timer()
-        self._camera_switch.restart_live_capture_from_side()
-
-
+    def addRecordFrame(self, latest_holder_barcode, plate, latest_holder_image, pins_image):
+        self._record_table.add_record_frame(latest_holder_barcode, plate, latest_holder_image, pins_image)
 
+    def isLatestHolderBarcode(self, holder_barcode):
+        return self._record_table.is_latest_holder_barcode(holder_barcode)

dls_barcode/gui/menu_bar.py

@@ -7,47 +7,53 @@ class MenuBar(QMainWindow):
     """ GUI component. Displays a start/stop button
     """
 
-    def __init__(self, mainMenu, version, clean_up, on_options_action_clicked, on_about_action_clicked):
+    def __init__(self, mainMenu, version):
         super(MenuBar, self).__init__()
         self._version = version
-        self._cleanup = clean_up
-        self._on_options_action_clicked = on_options_action_clicked
-        self._on_about_action_clicked = on_about_action_clicked
 
         self._exit_icon = self.style().standardIcon(QStyle.SP_DialogCloseButton)
         self._config_icon = self.style().standardIcon(QStyle.SP_FileDialogDetailedView)
         self._about_icon = self.style().standardIcon(QStyle.SP_FileDialogInfoView)
 
         self._mainMenu = mainMenu
+        self._exit_action = None
+        self._options_action = None
+        self._about_action = None
 
         self._init_ui()
 
     def _init_ui(self):
         """Create and populate the menu bar.
               """
         # Exit Application
-        exit_action = QAction(self._exit_icon, '&Exit', self)
-        exit_action.setShortcut('Ctrl+Q')
-        exit_action.setStatusTip('Exit application')
-        exit_action.triggered.connect(self._cleanup)
-        exit_action.triggered.connect(qApp.quit)
+        self._exit_action = QAction(self._exit_icon, '&Exit', self)
+        self._exit_action.setShortcut('Ctrl+Q')
+        self._exit_action.setStatusTip('Exit application')
 
         # Open options dialog
-        options_action = QAction(self._config_icon, '&Config', self)
-        options_action.setShortcut('Ctrl+O')
-        options_action.setStatusTip('Open Options Dialog')
-        options_action.triggered.connect(self._on_options_action_clicked)
+        self._options_action = QAction(self._config_icon, '&Config', self)
+        self._options_action.setShortcut('Ctrl+O')
+        self._options_action.setStatusTip('Open Options Dialog')
 
         # Show version number
-        about_action = QAction(self._about_icon, "About", self)
-        about_action.triggered.connect(self._on_about_action_clicked)
+        self._about_action = QAction(self._about_icon, "About", self)
 
         # Create menu bar
         file_menu = self._mainMenu.addMenu('&File')
-        file_menu.addAction(exit_action)
+        file_menu.addAction(self._exit_action)
 
         option_menu = self._mainMenu.addMenu('&Options')
-        option_menu.addAction(options_action)
+        option_menu.addAction(self._options_action)
 
         help_menu = self._mainMenu.addMenu('?')
-        help_menu.addAction(about_action)
+        help_menu.addAction(self._about_action)
+
+    def exit_action_triggered(self, cleanup):
+        self._exit_action.triggered.connect(cleanup)
+        self._exit_action.triggered.connect(qApp.quit)
+
+    def optiones_action_triggered(self, on_options_action_clicked):
+        self._options_action.triggered.connect(on_options_action_clicked)
+
+    def about_action_trigerred(self, on_about_action_clicked):
+        self._about_action.triggered.connect(on_about_action_clicked)