1693 lines
79 KiB
Python
1693 lines
79 KiB
Python
import time
|
|
|
|
import jwt
|
|
from PySide6.QtCore import Qt, Slot, Signal, QTimer, QSettings, QEvent
|
|
from PySide6.QtGui import QAction, QPixmap, QKeySequence
|
|
from PySide6.QtWidgets import (
|
|
QMainWindow,
|
|
QWidget,
|
|
QHBoxLayout,
|
|
QVBoxLayout,
|
|
QMessageBox,
|
|
QDockWidget,
|
|
QTabWidget)
|
|
|
|
from aare.common.auth_models import BatonStatus
|
|
from aare.common.coordinate import Coordinate, SmargonCoordinate
|
|
from aare.common.diffraction_geometry import DiffractionGeometry
|
|
from aare.common.logger_config import setup_logger
|
|
from aare.common.models import SampleShortInfoList, TokenData, DAQStatusModel, BeamlineStateEnum
|
|
from aare.common.sample_geometry import SampleGeometryModel
|
|
from aare.gui.models.gui_state_manager import UIStateManager
|
|
from aare.gui.panels.LogPanel import LogDock
|
|
|
|
from aare.gui.panels.beamline_controls import BeamlineControls
|
|
from aare.gui.panels.beamline_state_panel import BeamlineStatePanel
|
|
from aare.gui.panels.data_collection_settings import DataCollectionSettings
|
|
from aare.gui.panels.developer_help_dialog import DeveloperHelpDialog
|
|
from aare.gui.panels.beamline_recovery_panel import BeamlineRecoveryDialog
|
|
from aare.gui.panels.local_contact_panel import LocalContactDialog
|
|
from aare.gui.panels.manual_sample_panel import ManualSamplePanel
|
|
from aare.gui.panels.prediction_metrics_panel import PredictionMetricsPanel
|
|
from aare.gui.panels.reference_tools_panel import ReferenceToolsPanel
|
|
from aare.gui.panels.sample_queue_panel import SampleQueuePanel
|
|
from aare.gui.panels.target_stability_panel import TargetStabilityPanel
|
|
from aare.gui.panels.tell_sample_panel import TellSamplePanel
|
|
from aare.gui.panels.face_detection_panel import FaceDetectionPanel
|
|
from aare.gui.panels.smargon_trace_panel import SmargonTracePanel
|
|
from aare.gui.scan_logic.raster_grid_manager import RasterGridManager
|
|
from aare.gui.scan_logic.rotation_scan_manager import RotationScanManager
|
|
from aare.gui.scan_logic.sample_mount_logic import SampleMountLogic
|
|
from aare.gui.threads.axis_video_thread import VideoThread
|
|
|
|
from aare.gui.tutorials.tutorial_actions import TutorialActionExecutor
|
|
from aare.gui.tutorials.tutorial_manager import TutorialManager
|
|
from aare.gui.tutorials.tutorial_runtime import DictionaryTextResolver, TutorialEventBus
|
|
from aare.gui.tutorials.tutorial_targets import MainWindowTutorialTargetResolver
|
|
from aare.gui.tutorials.tutorial_registration import register_tutorials
|
|
from aare.gui.tutorials.tutroial_texts import MANUAL_MOUNT_TUTORIAL
|
|
|
|
from aare.gui.tutorials.controls_help_dialog import ControlsHelpDialog
|
|
|
|
from aare.gui.threads.camera_thread import SampleCameraThread
|
|
from aare.gui.threads.prediction_subscriber import PredictionSubscriber
|
|
from aare.gui.threads.daq_worker import DAQWorker
|
|
from aare.gui.threads.jfjoch_viewer import JFJochDBusClient
|
|
from aare.gui.tutorials.tutorial_registration import register_tutorials
|
|
from aare.gui.widgets.alert_banner import AlertBanner
|
|
from aare.gui.widgets.baton_request_dialog import BatonRequestDialog, BatonPendingDialog
|
|
from aare.gui.widgets.camera_image import SampleCameraImageLabel
|
|
from aare.gui.widgets.no_wheel_scroll_area import NoWheelScrollArea
|
|
from aare.gui.widgets.status_bar import StatusBar
|
|
from aare.gui.widgets.video_image import VideoGraphicsView
|
|
from aare.gui.panels.fluorescence_panel import FluorescencePanel
|
|
|
|
from aare.gui.panels.automation_panel import AutomationProgressWidget
|
|
|
|
logger = setup_logger("aareGUI")
|
|
|
|
class MainWindow(QMainWindow):
|
|
sample_geometry = Signal(SampleGeometryModel)
|
|
|
|
def __init__(self, base_url: str | None,
|
|
token: str,
|
|
default_image: str | None,
|
|
zmq_addr: str | None,
|
|
pred_zmq_addr: str | None,
|
|
beamline_cam_addr: str | None,
|
|
gonio_cam_addr: str | None,
|
|
gonio_cam_id: int | None
|
|
):
|
|
super().__init__()
|
|
|
|
self.__base_url = base_url
|
|
self.__token = token
|
|
self.__mounting = False
|
|
self.__samcam_feed_banner_active = False
|
|
self.__samcam_feed_banner_message = "Sample camera feed unavailable"
|
|
self._automation_critical_banner_active = False
|
|
self._dev_help_dialog = None
|
|
self._beamline_recovery_dialog = None
|
|
self._local_contact_dialog = None
|
|
self._controls_help_dialog = None
|
|
self._cleanup_done = False
|
|
self._default_window_state = None
|
|
|
|
self._waiting_for_baton_response: bool = False
|
|
self._baton_request_dialog: BatonRequestDialog | None = None
|
|
self._baton_pending_dialog: BatonPendingDialog | None = None
|
|
|
|
self._last_user_interaction_ts = time.time()
|
|
self._last_interaction_report_ts = 0.0
|
|
self._interaction_report_min_interval_s = 15.0
|
|
self._idle_close_timeout_s = 60 * 60
|
|
self._remote_close_deadline_ts: float | None = None
|
|
self._remote_close_reason: str | None = None
|
|
self._remote_close_banner_active: bool = False
|
|
self._latest_daq_status: DAQStatusModel | None = None
|
|
|
|
self._tutorial_event_bus = TutorialEventBus(self)
|
|
self._tutorial_text_resolver = DictionaryTextResolver(MANUAL_MOUNT_TUTORIAL)
|
|
self.state_manager = UIStateManager("PSI", "AareGUI")
|
|
self.viewer = JFJochDBusClient()
|
|
|
|
try:
|
|
token_str = (token or "").strip()
|
|
if token_str.count(".") != 2:
|
|
raise ValueError(
|
|
"Invalid authentication token received (not a JWT). "
|
|
"This usually happens when the server is not running or still starting."
|
|
)
|
|
|
|
payload = jwt.decode(token_str, options={"verify_signature": False})
|
|
self.__decoded_token = TokenData(**payload)
|
|
except Exception as e:
|
|
logger.error(f"Failed to decode authentication token: {e}", exc_info=True)
|
|
QMessageBox.critical(
|
|
None,
|
|
"Authentication Error",
|
|
"Could not start the GUI because authentication data was invalid.\n\n"
|
|
"Most commonly the server is not running yet (or is still initialising).\n"
|
|
"Please start/restart the server and try again."
|
|
)
|
|
raise
|
|
|
|
self.setStyleSheet("background-color: rgb(216, 228, 253);")
|
|
|
|
root_widget = QWidget(parent=self)
|
|
root_layout = QVBoxLayout(root_widget)
|
|
root_layout.setContentsMargins(0, 0, 0, 0)
|
|
root_layout.setSpacing(0)
|
|
|
|
self.alert_banner = AlertBanner(parent=root_widget)
|
|
root_layout.addWidget(self.alert_banner)
|
|
|
|
self.alert_banner_secondary = AlertBanner(parent=root_widget)
|
|
root_layout.addWidget(self.alert_banner_secondary)
|
|
|
|
top_widget = QWidget(parent=root_widget)
|
|
top_widget_layout = QHBoxLayout(top_widget)
|
|
top_widget.setLayout(top_widget_layout)
|
|
|
|
diffraction = DiffractionGeometry(
|
|
energy_keV=12.4,
|
|
dtz_mm=100,
|
|
detector_size_pxl=(1553, 1630),
|
|
pixel_size_mm=0.150, # PILATUS 4
|
|
beam_center_pxl=(750, 750),
|
|
detector_description="PILATUS 4",
|
|
detector_serial_number="1",
|
|
poni_rot1_rad=-0.001396263,
|
|
poni_rot2_rad=-0.003839724
|
|
)
|
|
|
|
geom = SampleGeometryModel(beam_location_pxl=Coordinate(x=1000, y=1000),
|
|
pixel_in_mm=0.001,
|
|
aerotech=Coordinate(),
|
|
smargon=SmargonCoordinate(sh_mm=Coordinate(), phi_deg=0, chi_deg=0),
|
|
omega_deg=0,
|
|
beam_size_mm=Coordinate(x=0.01, y=0.01),
|
|
aerotech_meas=Coordinate()
|
|
)
|
|
|
|
self.raster = RasterGridManager(geom=geom)
|
|
self.rotation = RotationScanManager()
|
|
|
|
collection_controls_scroll = NoWheelScrollArea(top_widget)
|
|
|
|
self.left_column = QWidget(parent=top_widget)
|
|
self.left_column_layout = QVBoxLayout(self.left_column)
|
|
self.left_column_layout.setContentsMargins(0, 0, 0, 0)
|
|
self.left_column_layout.setSpacing(8)
|
|
|
|
self.data_collection = DataCollectionSettings(s=geom,
|
|
parent=self.left_column,
|
|
raster_mgr=self.raster,
|
|
diffraction=diffraction)
|
|
|
|
self.beamline_state_panel = BeamlineStatePanel(parent=self.left_column)
|
|
|
|
self.left_column_layout.addWidget(self.data_collection)
|
|
self.left_column_layout.addWidget(self.beamline_state_panel)
|
|
self.left_column_layout.addStretch()
|
|
|
|
top_widget_layout.addWidget(collection_controls_scroll)
|
|
collection_controls_scroll.setWidget(self.left_column)
|
|
collection_controls_scroll.setHorizontalScrollBarPolicy(
|
|
Qt.ScrollBarPolicy.ScrollBarAlwaysOff
|
|
)
|
|
collection_controls_scroll.setWidgetResizable(True)
|
|
collection_controls_scroll.setFixedWidth(
|
|
max(self.data_collection.set_width, self.beamline_state_panel.set_width) + 10
|
|
)
|
|
|
|
self.video_tab = QTabWidget(parent=top_widget)
|
|
|
|
self.sample_camera = SampleCameraImageLabel(geom=geom, raster=self.raster, parent=top_widget,
|
|
default_image=default_image)
|
|
|
|
self.beamline_view_container = QWidget(parent=top_widget)
|
|
self.beamline_view_layout = QVBoxLayout(self.beamline_view_container)
|
|
self.beamline_view_layout.setContentsMargins(0, 0, 0, 0)
|
|
self.beamline_view_layout.setSpacing(6)
|
|
|
|
self.beamline_view_1_combined = VideoGraphicsView()
|
|
self.beamline_view_2_combined = VideoGraphicsView()
|
|
self.beamline_view_layout.addWidget(self.beamline_view_1_combined)
|
|
self.beamline_view_layout.addWidget(self.beamline_view_2_combined)
|
|
|
|
self.beamline_view = VideoGraphicsView()
|
|
if beamline_cam_addr:
|
|
self.beamline_camera_thread = VideoThread(ip=beamline_cam_addr)
|
|
self.beamline_camera_thread.frame_ready.connect(self.beamline_view.update_frame)
|
|
self.beamline_camera_thread.frame_ready.connect(self.beamline_view_2_combined.update_frame)
|
|
self.beamline_camera_thread.start()
|
|
self.beamline_view_layout.addWidget(self.beamline_view)
|
|
|
|
self.gonio_view = VideoGraphicsView()
|
|
# TODO add option to change cameras for gonio_camera_thread
|
|
if gonio_cam_addr and gonio_cam_id:
|
|
self.gonio_camera_thread = VideoThread(ip=gonio_cam_addr, camera=gonio_cam_id)
|
|
self.gonio_camera_thread.frame_ready.connect(self.gonio_view.update_frame)
|
|
self.gonio_camera_thread.frame_ready.connect(self.beamline_view_1_combined.update_frame)
|
|
self.gonio_camera_thread.start()
|
|
self.beamline_view_layout.addWidget(self.gonio_view)
|
|
|
|
self.video_tab.addTab(self.sample_camera, "Sample camera")
|
|
self.video_tab.addTab(self.gonio_view, "Gonio camera")
|
|
self.video_tab.addTab(self.beamline_view, "Beamline view")
|
|
self.video_tab.addTab(self.beamline_view_container, "Beamline combined view")
|
|
|
|
top_widget_layout.addWidget(self.video_tab)
|
|
|
|
beamline_controls_scroll = NoWheelScrollArea(top_widget)
|
|
|
|
self.beamline = BeamlineControls(beamline_controls_scroll, staff=self.__decoded_token.staff)
|
|
top_widget_layout.addWidget(beamline_controls_scroll)
|
|
beamline_controls_scroll.setWidget(self.beamline)
|
|
beamline_controls_scroll.setHorizontalScrollBarPolicy(
|
|
Qt.ScrollBarPolicy.ScrollBarAlwaysOff
|
|
)
|
|
beamline_controls_scroll.setFixedWidth(self.beamline.set_width + 10)
|
|
|
|
self.tell_samples = TellSamplePanel(samples=SampleShortInfoList(s=[]))
|
|
self.ref_tools_panel = ReferenceToolsPanel(samples=SampleShortInfoList(s=[]))
|
|
self.job_list_panel = SampleQueuePanel()
|
|
|
|
self.tell_samples_dock = QDockWidget("Sample List", self)
|
|
self.tell_samples_dock.setObjectName("tell_samples_dock")
|
|
self.tell_samples_dock.setWidget(self.tell_samples)
|
|
self.tell_samples_dock.setAllowedAreas(Qt.DockWidgetArea.BottomDockWidgetArea)
|
|
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.tell_samples_dock)
|
|
|
|
self.ref_tools_dock = QDockWidget("Reference Tools", self)
|
|
self.ref_tools_dock.setObjectName("ref_tools_dock")
|
|
self.ref_tools_dock.setWidget(self.ref_tools_panel)
|
|
self.ref_tools_dock.setAllowedAreas(Qt.DockWidgetArea.BottomDockWidgetArea)
|
|
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.ref_tools_dock)
|
|
self.tabifyDockWidget(self.ref_tools_dock, self.tell_samples_dock)
|
|
if self.__decoded_token.staff:
|
|
self.ref_tools_dock.show()
|
|
self.ref_tools_dock.raise_()
|
|
else:
|
|
self.ref_tools_dock.hide()
|
|
|
|
self.sample_logic = SampleMountLogic()
|
|
|
|
self.job_list_dock = QDockWidget("Automation list", self)
|
|
self.job_list_dock.setObjectName("job_list_dock")
|
|
self.job_list_dock.setWidget(self.job_list_panel)
|
|
self.job_list_dock.setAllowedAreas(Qt.DockWidgetArea.BottomDockWidgetArea)
|
|
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.job_list_dock)
|
|
|
|
self.manual_sample_panel = ManualSamplePanel()
|
|
|
|
self.manual_sample_dock = QDockWidget("Manual sample", self)
|
|
self.manual_sample_dock.setObjectName("manual_sample_dock")
|
|
self.manual_sample_dock.setWidget(self.manual_sample_panel)
|
|
self.manual_sample_dock.setAllowedAreas(Qt.DockWidgetArea.BottomDockWidgetArea)
|
|
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.manual_sample_dock)
|
|
|
|
self.automation_progress_panel = AutomationProgressWidget()
|
|
self.automation_progress_dock = QDockWidget("Automation progress", self)
|
|
self.automation_progress_dock.setObjectName("automation_progress_dock")
|
|
self.automation_progress_dock.setWidget(self.automation_progress_panel)
|
|
self.automation_progress_dock.setAllowedAreas(Qt.DockWidgetArea.BottomDockWidgetArea)
|
|
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.automation_progress_dock)
|
|
|
|
self.face_panel = FaceDetectionPanel()
|
|
self.face_panel_dock = QDockWidget("Face detection", self)
|
|
self.face_panel_dock.setObjectName("face_panel_dock")
|
|
self.face_panel_dock.setWidget(self.face_panel)
|
|
self.face_panel_dock.setAllowedAreas(
|
|
Qt.DockWidgetArea.RightDockWidgetArea | Qt.DockWidgetArea.LeftDockWidgetArea)
|
|
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.face_panel_dock)
|
|
self.face_panel_dock.hide()
|
|
|
|
self.fluor_panel = FluorescencePanel()
|
|
self.fluor_panel_dock = QDockWidget("Fluorescence", self)
|
|
self.fluor_panel_dock.setObjectName("fluor_panel_dock")
|
|
self.fluor_panel_dock.setWidget(self.fluor_panel)
|
|
self.fluor_panel_dock.setAllowedAreas(
|
|
Qt.DockWidgetArea.TopDockWidgetArea | Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
|
|
self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self.fluor_panel_dock)
|
|
self.fluor_panel_dock.hide()
|
|
|
|
# Create and add the dock to your main window
|
|
self.log_dock = LogDock("Console Log", self)
|
|
self.log_dock.setObjectName("log_dock")
|
|
self.addDockWidget(Qt.BottomDockWidgetArea, self.log_dock)
|
|
self.log_dock.attach_logger("")
|
|
self.log_dock.attach_logger("aareGUI")
|
|
self.log_dock.hide()
|
|
|
|
self.tabifyDockWidget(self.manual_sample_dock, self.automation_progress_dock)
|
|
self.tabifyDockWidget(self.automation_progress_dock, self.log_dock)
|
|
|
|
self.job_list_panel.samples_in_queue_changed.connect(
|
|
self.automation_progress_panel.set_samples_in_queue
|
|
)
|
|
self.job_list_panel.automation_running_changed.connect(
|
|
self.automation_progress_panel.set_running
|
|
)
|
|
self.job_list_panel.automation_running_changed.connect(
|
|
self._on_automation_running_changed
|
|
)
|
|
self.automation_progress_panel.set_samples_in_queue(
|
|
len(self.job_list_panel.table_model.samples)
|
|
)
|
|
self.automation_progress_panel.set_running(self.job_list_panel.is_running())
|
|
|
|
# smargon trace panel
|
|
self.smargon_trace_panel = SmargonTracePanel()
|
|
self.smargon_trace_dock = QDockWidget("Smargon trace", self)
|
|
self.smargon_trace_dock.setObjectName("smargon_trace_dock")
|
|
self.smargon_trace_dock.setWidget(self.smargon_trace_panel)
|
|
self.smargon_trace_dock.setAllowedAreas(
|
|
Qt.DockWidgetArea.RightDockWidgetArea
|
|
| Qt.DockWidgetArea.LeftDockWidgetArea
|
|
| Qt.DockWidgetArea.BottomDockWidgetArea
|
|
)
|
|
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.smargon_trace_dock)
|
|
self.smargon_trace_dock.hide()
|
|
|
|
#Target stability panel
|
|
self.target_stability_panel = TargetStabilityPanel()
|
|
self.target_stability_dock = QDockWidget("Target stability", self)
|
|
self.target_stability_dock.setObjectName("target_stability_dock")
|
|
self.target_stability_dock.setWidget(self.target_stability_panel)
|
|
self.target_stability_dock.setAllowedAreas(
|
|
Qt.DockWidgetArea.RightDockWidgetArea
|
|
| Qt.DockWidgetArea.LeftDockWidgetArea
|
|
| Qt.DockWidgetArea.BottomDockWidgetArea
|
|
)
|
|
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.target_stability_dock)
|
|
self.target_stability_dock.hide()
|
|
|
|
# Prediction Metrics Panel
|
|
self.prediction_metrics_panel = PredictionMetricsPanel()
|
|
self.prediction_metrics_dock = QDockWidget("Prediction Metrics", self)
|
|
self.prediction_metrics_dock.setObjectName("prediction_metrics_dock")
|
|
self.prediction_metrics_dock.setWidget(self.prediction_metrics_panel)
|
|
self.prediction_metrics_dock.setAllowedAreas(
|
|
Qt.DockWidgetArea.RightDockWidgetArea
|
|
| Qt.DockWidgetArea.LeftDockWidgetArea
|
|
| Qt.DockWidgetArea.BottomDockWidgetArea
|
|
)
|
|
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.prediction_metrics_dock)
|
|
self.prediction_metrics_dock.hide()
|
|
|
|
root_layout.addWidget(top_widget)
|
|
self.setCentralWidget(root_widget)
|
|
|
|
self.setWindowTitle("AareGUI")
|
|
self.create_menu_bar()
|
|
self._setup_global_shortcuts()
|
|
self._capture_default_window_state()
|
|
self._restore_window_state()
|
|
|
|
# Define tutorials now that the UI exists
|
|
self._tutorial_target_resolver = MainWindowTutorialTargetResolver(self)
|
|
self._tutorial_action_executor = TutorialActionExecutor(self)
|
|
|
|
self.tutorial_manager = TutorialManager(
|
|
self,
|
|
target_resolver=self._tutorial_target_resolver,
|
|
text_resolver=self._tutorial_text_resolver,
|
|
action_executor=self._tutorial_action_executor,
|
|
event_bus=self._tutorial_event_bus,
|
|
)
|
|
|
|
self.status_bar = StatusBar(self.__decoded_token, parent=self)
|
|
self.setStatusBar(self.status_bar)
|
|
|
|
self.daq = DAQWorker(base_url=self.__base_url, token=self.__token)
|
|
|
|
self.installEventFilter(self)
|
|
|
|
self._idle_timer = QTimer(self)
|
|
self._idle_timer.setInterval(60_000)
|
|
self._idle_timer.timeout.connect(self._check_idle_timeout)
|
|
self._idle_timer.start()
|
|
|
|
self._remote_close_timer = QTimer(self)
|
|
self._remote_close_timer.setInterval(1000)
|
|
self._remote_close_timer.timeout.connect(self._check_remote_close_deadline)
|
|
|
|
self.daq.baton_status_changed.connect(self.status_bar.update_baton_status)
|
|
self.daq.baton_status_changed.connect(self._on_baton_status_changed)
|
|
self.daq.baton_request_result.connect(self._on_baton_request_result)
|
|
self.daq.baton_response_result.connect(self._on_baton_response_result)
|
|
self.daq.baton_timeout_checked.connect(self._on_baton_timeout_checked)
|
|
self.daq.automation_progress.connect(self.automation_progress_panel.set_progress)
|
|
|
|
self.status_bar.baton_request_received.connect(self._show_baton_request_dialog)
|
|
self.status_bar.baton_request_accepted.connect(self._accept_baton_request)
|
|
self.status_bar.baton_request_refused.connect(self._refuse_baton_request)
|
|
|
|
self.daq.spreadsheet.connect(self.tell_samples.new_sample_list)
|
|
if self.__decoded_token.staff:
|
|
self.daq.reference_tools.connect(self.ref_tools_panel.new_list)
|
|
|
|
self.beamline.samcam.changed.connect(self.daq.samcam_settings)
|
|
self.beamline.samcam.screenshot_requested.connect(self.daq.send_screenshot_db)
|
|
self.beamline.loopctr.find_tip.clicked.connect(self.daq.center_loop)
|
|
self.beamline.loopctr.bounding_box.clicked.connect(self.daq.ml_bounding_box)
|
|
self.daq.raster_generated_by_ml.connect(self.raster.update_active_grid_request)
|
|
|
|
self.sample_camera.smargon.connect(self.daq.move_smargon)
|
|
self.beamline.smargon_panel.smargon.connect(self.daq.move_smargon)
|
|
self.sample_camera.samcam_updated.connect(self.daq.samcam_settings)
|
|
|
|
self.raster.omega.connect(self.daq.set_omega)
|
|
self.raster.smargon.connect(self.daq.move_smargon)
|
|
|
|
self.beamline.omega_panel.set_omega_rel.connect(self.daq.set_omega_rel)
|
|
self.beamline.omega_panel.set_omega.connect(self.daq.set_omega)
|
|
self.sample_camera.set_omega.connect(self.daq.set_omega)
|
|
self.beamline.zoom_panel.zoom.connect(self.daq.zoom)
|
|
self.beamline.illumination_panel.front_light.connect(self.daq.front_light)
|
|
self.beamline.illumination_panel.back_light.connect(self.daq.back_light)
|
|
|
|
if self.__decoded_token.staff:
|
|
self.beamline.abr_tweak.abr_tweak.connect(self.daq.abr_tweak)
|
|
self.beamline.abr_tweak.abr_save.connect(self.daq.abr_save)
|
|
self.beamline.abr_tweak.abr_goto_meas.connect(self.daq.abr_goto_meas)
|
|
|
|
self.beamline.beam_mark.beam_mark_clear.connect(self.daq.beam_mark_clear)
|
|
self.sample_camera.update_beam_mark.connect(self.daq.beam_mark_add)
|
|
self.beamline.beam_center.beam_center.connect(self.daq.beam_center)
|
|
self.beamline.beam_size.beam_size.connect(self.daq.beam_size_mm)
|
|
|
|
self.sample_camera.load_image.connect(self.raster.load_image)
|
|
self.sample_camera.switch_raster_grid.connect(self.data_collection.switch_to_raster)
|
|
self.beamline.samcam.show_detections_changed.connect(self.sample_camera.set_show_detections)
|
|
self.beamline.samcam.show_detection_polygons_changed.connect(self.sample_camera.set_show_detection_polygons)
|
|
self.beamline.samcam.show_target_point_changed.connect(self.sample_camera.set_show_target_point)
|
|
self.beamline.samcam.show_target_coordinates_changed.connect(self.sample_camera.set_show_target_coordinates)
|
|
self.beamline.samcam.show_overlay_legend_changed.connect(self.sample_camera.set_show_overlay_legend)
|
|
self.beamline.samcam.compact_overlay_legend_changed.connect(self.sample_camera.set_compact_overlay_legend)
|
|
self.beamline.samcam.target_color_changed.connect(self.sample_camera.set_target_color)
|
|
self._restore_samcam_overlay_settings()
|
|
|
|
if zmq_addr is not None:
|
|
self.camera_thread = SampleCameraThread(zmq_url=zmq_addr)
|
|
self.camera_thread.start()
|
|
self.camera_thread.focus_measure.connect(self.status_bar.update_sharpness)
|
|
self.camera_thread.fps_measure.connect(self.status_bar.update_samcam_fps)
|
|
self.camera_thread.camera_availability_changed.connect(self.sample_camera.set_camera_available)
|
|
self.camera_thread.camera_availability_changed.connect(self._on_sample_camera_availability_changed)
|
|
self.camera_thread.camera_error.connect(self._on_sample_camera_error)
|
|
else:
|
|
self.camera_thread = None
|
|
self.sample_camera.set_camera_available(False)
|
|
self._show_samcam_feed_banner("Sample camera feed unavailable: no stream configured")
|
|
|
|
# Prediction subscriber thread
|
|
if pred_zmq_addr is not None:
|
|
logger.debug(f"Starting prediction subscriber thread {pred_zmq_addr}")
|
|
self.prediction_thread = PredictionSubscriber(pred_zmq_url=pred_zmq_addr, topic="detections")
|
|
self.prediction_thread.prediction.connect(self.sample_camera.update_detections)
|
|
self.prediction_thread.prediction.connect(self.prediction_metrics_panel.update_from_prediction)
|
|
self.prediction_thread.target_point.connect(self.sample_camera.update_target_point)
|
|
self.prediction_thread.target_point.connect(self.target_stability_panel.update_target_point)
|
|
self.prediction_thread.start()
|
|
else:
|
|
self.prediction_thread = None
|
|
|
|
self._last_pred_image_ts: float | None = None
|
|
self._pred_preferred_timeout_s: float = 0.7 # tune: how long we "trust" prediction images
|
|
self._pred_is_preferred: bool = False
|
|
|
|
if self.camera_thread is not None:
|
|
self.camera_thread.camera_image.connect(self._on_samcam_camera_pixmap)
|
|
|
|
if self.prediction_thread is not None:
|
|
self.prediction_thread.image.connect(self._on_samcam_prediction_pixmap)
|
|
|
|
self._samcam_source_timer = QTimer(self)
|
|
self._samcam_source_timer.setInterval(200) # ms
|
|
self._samcam_source_timer.timeout.connect(self._update_samcam_source_preference)
|
|
self._samcam_source_timer.start()
|
|
|
|
#
|
|
# self.data_collection.helical.helical_scan.connect(self.worker.helical_scan)
|
|
# self.data_collection.helical.update_bookmarks.connect(
|
|
# self.camera_image.update_bookmarks
|
|
# )
|
|
#
|
|
|
|
self.sample_camera.autofocus.connect(self.daq.autofocus)
|
|
|
|
self.sample_camera.evaluate_grid.connect(self.raster.run_grid_scan)
|
|
self.data_collection.raster.evaluate_grid.connect(self.raster.run_grid_scan)
|
|
self.data_collection.raster.evaluate_grid_auto.connect(self.raster.run_grid_scan_auto)
|
|
|
|
self.sample_camera.clear_evaluated_grids.connect(self.raster.clear_completed_grids)
|
|
self.sample_camera.clear_grid.connect(self.raster.clear_active_grid)
|
|
self.daq.run_number_incremented.connect(self.data_collection.file_path_panel.increment_run_number)
|
|
|
|
self.job_list_panel.auto_scan.connect(self.daq.automated_scan)
|
|
|
|
self.job_list_panel.unmount.connect(self.daq.unmount)
|
|
self.job_list_panel.park_and_dry.connect(self.daq.park_and_dry)
|
|
|
|
self.tell_samples.mount.connect(self.daq.mount)
|
|
self.tell_samples.unmount.connect(self.daq.unmount)
|
|
self.ref_tools_panel.mount.connect(self.daq.mount)
|
|
self.ref_tools_panel.unmount.connect(self.daq.unmount)
|
|
|
|
self.data_collection.raster.grid_size_updated.connect(self.raster.update_grid_size)
|
|
self.data_collection.raster.exp_time_updated.connect(self.raster.update_exposure_time)
|
|
self.data_collection.raster.transmission_updated.connect(self.raster.update_transmission)
|
|
self.data_collection.raster.dtz_updated.connect(self.raster.update_dtz)
|
|
self.data_collection.raster.grid_metric_updated.connect(self.raster.metric)
|
|
self.data_collection.raster.raster_alpha_changed.connect(self.sample_camera.raster_alpha)
|
|
self.data_collection.cancel.connect(self.daq.cancel)
|
|
|
|
self.raster.grid_scan.connect(self.daq.raster_scan)
|
|
self.raster.grid_scan_auto.connect(self.daq.raster_scan_auto)
|
|
self.data_collection.screening.rotation_scan.connect(self.daq.standard_scan)
|
|
self.data_collection.simple.rotation_scan.connect(self.daq.standard_scan)
|
|
self.data_collection.simple.parameters_changed.connect(self.daq.smart_params)
|
|
|
|
self.raster.grid_scan_size_changed.connect(self.data_collection.raster.grid_scan_size_change)
|
|
|
|
self.status_bar.set_pgroup.connect(self.daq.set_pgroup)
|
|
self.status_bar.end_session.connect(self.daq.end_session)
|
|
self.status_bar.force_session.connect(self.daq.force_session)
|
|
|
|
self.status_bar.request_baton.connect(self.daq.request_baton)
|
|
self.status_bar.cancel_baton_request.connect(self.daq.cancel_baton_request)
|
|
self.status_bar.release_baton.connect(self.daq.release_baton)
|
|
self.status_bar.baton_request_accepted.connect(
|
|
lambda: self.daq.respond_to_baton_request(True)
|
|
)
|
|
self.status_bar.baton_request_refused.connect(
|
|
lambda: self.daq.respond_to_baton_request(False)
|
|
)
|
|
|
|
self.status_bar.dewar_exchange.connect(self.daq.dewar_exchange)
|
|
self.status_bar.sample_exchange.connect(self.daq.sample_exchange)
|
|
self.status_bar.sample_alignment.connect(self.daq.sample_alignment)
|
|
self.status_bar.beam_location.connect(self.daq.beam_location)
|
|
|
|
self.status_bar.close_shutter.connect(self.daq.close_shutter)
|
|
self.status_bar.open_shutter.connect(self.daq.open_shutter)
|
|
|
|
self.beamline_state_panel.dewar_exchange.connect(self.daq.dewar_exchange)
|
|
self.beamline_state_panel.sample_exchange.connect(self.daq.sample_exchange)
|
|
self.beamline_state_panel.sample_alignment.connect(self.daq.sample_alignment)
|
|
self.beamline_state_panel.beam_location.connect(self.daq.beam_location)
|
|
self.beamline_state_panel.data_collection.connect(self.daq.data_collection)
|
|
self.beamline_state_panel.xtal_snapshot.connect(self.daq.xtal_snapshot)
|
|
self.beamline_state_panel.xray_fluorescence.connect(self.daq.xray_fluorescence)
|
|
self.beamline_state_panel.robot_sample_exchange.connect(self.daq.robot_sample_exchange)
|
|
self.rotation.file_ready.connect(self.viewer.load_image)
|
|
self.raster.image_selected.connect(self.viewer.load_image)
|
|
|
|
self.raster.viewer_track_online.connect(self.viewer.load_online)
|
|
self.data_collection.screening.viewer_track_online.connect(self.viewer.load_online)
|
|
self.job_list_panel.viewer_track_online.connect(self.viewer.load_online)
|
|
|
|
self.sample_logic.sample_changed.connect(self.data_collection.file_path_panel.update_sample)
|
|
|
|
self.daq.update.connect(self.beamline.omega_panel.update_daq_status)
|
|
self.daq.update.connect(self.beamline.smargon_panel.update_daq_status)
|
|
self.daq.update.connect(self.job_list_panel.update_daq_status)
|
|
self.daq.update.connect(self.data_collection.file_path_panel.update_daq_status)
|
|
|
|
self.daq.update.connect(self.data_collection.update_daq_status)
|
|
self.daq.update.connect(self.beamline.illumination_panel.update_daq_status)
|
|
self.daq.update.connect(self.raster.update_daq_status)
|
|
self.daq.update.connect(self.sample_camera.update_daq_status)
|
|
self.daq.update.connect(self.tell_samples.update_daq_status)
|
|
self.daq.update.connect(self.ref_tools_panel.update_daq_status)
|
|
if self.camera_thread is not None:
|
|
self.daq.update.connect(self.camera_thread.update_daq_status)
|
|
|
|
if self.__decoded_token.staff:
|
|
self.daq.update.connect(self.beamline.beam_size.update_daq_status)
|
|
self.daq.update.connect(self.beamline.beam_center.update_daq_status)
|
|
self.daq.update.connect(self.beamline.abr_tweak.update_daq_status)
|
|
self.daq.update.connect(self.beamline.beam_mark.update_daq_status)
|
|
self.daq.update.connect(self.status_bar.update_daq_status)
|
|
self.daq.update.connect(self.beamline.samcam.update_daq_status)
|
|
self.daq.update.connect(self.beamline.zoom_panel.update_daq_status)
|
|
|
|
self.daq.update.connect(self.sample_logic.update_daq_status)
|
|
self.daq.update.connect(self.manual_sample_panel.update_daq_status)
|
|
self.daq.update.connect(self.fluor_panel.update_daq_status)
|
|
self.daq.update.connect(self.beamline_state_panel.update_daq_status)
|
|
self.daq.update.connect(self.update_daq_status)
|
|
|
|
self.daq.sample_missing.connect(self.show_sample_missing_dialog)
|
|
|
|
self.daq.standard_scan_completed.connect(self.rotation.scan_completed)
|
|
self.daq.raster_scan_completed.connect(self.raster.grid_scan_completed)
|
|
|
|
self.daq.automated_scan_done.connect(self.job_list_panel.automated_scan_done)
|
|
self.daq.automation_critical_failure.connect(self._on_automation_critical_failure)
|
|
self.daq.manual_collection_critical_failure.connect(self._on_manual_collection_critical_failure)
|
|
self.daq.recovery_action_completed.connect(lambda _msg: self._clear_automation_critical_banner())
|
|
|
|
self.manual_sample_panel.sample_manual.connect(self.daq.sample_manual)
|
|
self.face_panel.face_detection.connect(self.daq.face_detection)
|
|
self.daq.face_detection_result.connect(self.face_panel.update_plot)
|
|
|
|
self.status_bar.get_all_pgroups.connect(self.daq.get_all_pgroups)
|
|
self.daq.staff_pgroups_loaded.connect(self.status_bar.staff_pgroups_loaded)
|
|
|
|
self.data_collection.fluo.fluo_scan.connect(self.daq.fluorimeter_spectrum)
|
|
self.daq.fluorimeter_spectrum_update.connect(self.fluor_panel.update_plot)
|
|
self.daq.fluorimeter_spectrum_update.connect(lambda: self.fluor_panel_dock.setVisible(True))
|
|
|
|
# === Alert/Status Message Routing ===
|
|
# Primary alert banner: Infrastructure devices (Server/Tell/Smargon/Aerotech)
|
|
self.daq.polled_devices_status.connect(self.alert_banner.show_message)
|
|
|
|
# Secondary alert banner: Detector errors (JFJoch)
|
|
self.daq.detector_error.connect(self.alert_banner_secondary.show_message)
|
|
|
|
# Status bar: General status messages (not device connection status)
|
|
self.daq.status_message.connect(self.status_bar.show_connection_message)
|
|
|
|
register_tutorials(self, self.tutorial_manager)
|
|
|
|
def _setup_global_shortcuts(self) -> None:
|
|
self._shortcut_manual_sample = QAction("Raise Manual Sample Dock", self)
|
|
self._shortcut_manual_sample.setShortcut(QKeySequence("Ctrl+M"))
|
|
self._shortcut_manual_sample.triggered.connect(
|
|
lambda: (self.manual_sample_dock.setVisible(True), self.manual_sample_dock.raise_()))
|
|
self.addAction(self._shortcut_manual_sample)
|
|
|
|
self._shortcut_raise_sample_list = QAction("Raise sample list", self)
|
|
self._shortcut_raise_sample_list.setShortcut(QKeySequence("Ctrl+L"))
|
|
self._shortcut_raise_sample_list.triggered.connect(
|
|
lambda: (self.tell_samples_dock.setVisible(True), self.tell_samples_dock.raise_())
|
|
)
|
|
self.addAction(self._shortcut_raise_sample_list)
|
|
|
|
self._shortcut_raise_reference_tools_list = QAction("Raise reference tools", self)
|
|
self._shortcut_raise_reference_tools_list.setShortcut(QKeySequence("Ctrl+R"))
|
|
self._shortcut_raise_reference_tools_list.triggered.connect(
|
|
lambda: (self.ref_tools_dock.setVisible(True), self.ref_tools_dock.raise_())
|
|
)
|
|
self.addAction(self._shortcut_raise_reference_tools_list)
|
|
|
|
self._shortcut_raise_job_list = QAction("Raise automation list", self)
|
|
self._shortcut_raise_job_list.setShortcut(QKeySequence("Ctrl+J"))
|
|
self._shortcut_raise_job_list.triggered.connect(
|
|
lambda: (self.job_list_dock.setVisible(True), self.job_list_dock.raise_())
|
|
)
|
|
self.addAction(self._shortcut_raise_job_list)
|
|
|
|
self._shortcut_toggle_target_stability = QAction("Toggle target stability panel", self)
|
|
self._shortcut_toggle_target_stability.setShortcut(QKeySequence("Ctrl+Shift+T"))
|
|
self._shortcut_toggle_target_stability.triggered.connect(
|
|
lambda: self.target_stability_dock.setVisible(not self.target_stability_dock.isVisible())
|
|
)
|
|
self.addAction(self._shortcut_toggle_target_stability)
|
|
|
|
self._shortcut_toggle_prediction_metrics = QAction("Toggle prediction metrics panel", self)
|
|
self._shortcut_toggle_prediction_metrics.setShortcut(QKeySequence("Ctrl+Shift+P"))
|
|
self._shortcut_toggle_prediction_metrics.triggered.connect(
|
|
lambda: self.prediction_metrics_dock.setVisible(not self.prediction_metrics_dock.isVisible())
|
|
)
|
|
self.addAction(self._shortcut_toggle_prediction_metrics)
|
|
|
|
self._shortcut_toggle_smargon_trace = QAction("Toggle smargon trace panel", self)
|
|
self._shortcut_toggle_smargon_trace.setShortcut(QKeySequence("Ctrl+Shift+S"))
|
|
self._shortcut_toggle_smargon_trace.triggered.connect(
|
|
lambda: self.smargon_trace_dock.setVisible(not self.smargon_trace_dock.isVisible())
|
|
)
|
|
self.addAction(self._shortcut_toggle_smargon_trace)
|
|
|
|
self._shortcut_console_log = QAction("Toggle Console Log", self)
|
|
self._shortcut_console_log.setShortcut(QKeySequence("Ctrl+Shift+L"))
|
|
self._shortcut_console_log.triggered.connect(
|
|
lambda: (self.log_dock.setVisible(True), self.log_dock.raise_())
|
|
)
|
|
self.addAction(self._shortcut_console_log)
|
|
|
|
def _restore_samcam_overlay_settings(self) -> None:
|
|
settings = QSettings("PSI", "AareGUI")
|
|
show_detections = settings.value("samcam/show_detections", True, type=bool)
|
|
show_detection_polygons = settings.value("samcam/show_detection_polygons", True, type=bool)
|
|
show_target_point = settings.value("samcam/show_target_point", True, type=bool)
|
|
show_target_coordinates = settings.value("samcam/show_target_coordinates", True, type=bool)
|
|
show_overlay_legend = settings.value("samcam/show_overlay_legend", True, type=bool)
|
|
compact_overlay_legend = settings.value("samcam/compact_overlay_legend", False, type=bool)
|
|
target_color = settings.value("samcam/target_color", "Cyan", type=str)
|
|
|
|
self.beamline.samcam.apply_overlay_settings(
|
|
show_detections=show_detections,
|
|
show_detection_polygons=show_detection_polygons,
|
|
show_target_point=show_target_point,
|
|
show_target_coordinates=show_target_coordinates,
|
|
show_overlay_legend=show_overlay_legend,
|
|
compact_overlay_legend=compact_overlay_legend,
|
|
target_color=target_color,
|
|
)
|
|
self.sample_camera.set_show_detections(show_detections)
|
|
self.sample_camera.set_show_detection_polygons(show_detection_polygons)
|
|
self.sample_camera.set_show_target_point(show_target_point)
|
|
self.sample_camera.set_show_target_coordinates(show_target_coordinates)
|
|
self.sample_camera.set_show_overlay_legend(show_overlay_legend)
|
|
self.sample_camera.set_compact_overlay_legend(compact_overlay_legend)
|
|
self.sample_camera.set_target_color(target_color)
|
|
|
|
def _save_samcam_overlay_settings(self) -> None:
|
|
settings = QSettings("PSI", "AareGUI")
|
|
overlay = self.sample_camera.target_overlay_settings()
|
|
settings.setValue("samcam/show_detections", overlay["show_detections"])
|
|
settings.setValue("samcam/show_detection_polygons", overlay["show_detection_polygons"]) # NEW
|
|
settings.setValue("samcam/show_target_point", overlay["show_target_point"])
|
|
settings.setValue("samcam/show_target_coordinates", overlay["show_target_coordinates"])
|
|
settings.setValue("samcam/show_overlay_legend", overlay["show_overlay_legend"])
|
|
settings.setValue("samcam/compact_overlay_legend", overlay["compact_overlay_legend"])
|
|
settings.setValue("samcam/target_color", overlay["target_color"])
|
|
|
|
@Slot(QPixmap)
|
|
def _on_samcam_prediction_pixmap(self, pix: QPixmap) -> None:
|
|
self._last_pred_image_ts = time.monotonic()
|
|
self._pred_is_preferred = True
|
|
self.sample_camera.update_pixmap(pix)
|
|
|
|
@Slot(QPixmap)
|
|
def _on_samcam_camera_pixmap(self, pix: QPixmap) -> None:
|
|
# Only show camera frames when prediction is not currently "healthy"
|
|
if not self._pred_is_preferred:
|
|
self.sample_camera.update_pixmap(pix)
|
|
|
|
@Slot()
|
|
def _update_samcam_source_preference(self) -> None:
|
|
if self.prediction_thread is None:
|
|
self._pred_is_preferred = False
|
|
return
|
|
|
|
if self._last_pred_image_ts is None:
|
|
self._pred_is_preferred = False
|
|
return
|
|
|
|
age_s = time.monotonic() - self._last_pred_image_ts
|
|
self._pred_is_preferred = age_s <= self._pred_preferred_timeout_s
|
|
|
|
@Slot(bool)
|
|
def _on_sample_camera_availability_changed(self, available: bool) -> None:
|
|
if available:
|
|
self._clear_samcam_feed_banner()
|
|
return
|
|
|
|
self._show_samcam_feed_banner("Sample camera feed unavailable")
|
|
|
|
@Slot(str)
|
|
def _on_sample_camera_error(self, message: str) -> None:
|
|
logger.warning(message)
|
|
self._show_samcam_feed_banner(message or "Sample camera feed unavailable")
|
|
|
|
def _show_samcam_feed_banner(self, message: str) -> None:
|
|
self.__samcam_feed_banner_message = message
|
|
self.alert_banner_secondary.show_message(message, True)
|
|
self.__samcam_feed_banner_active = True
|
|
|
|
def _clear_samcam_feed_banner(self) -> None:
|
|
if not self.__samcam_feed_banner_active:
|
|
return
|
|
self.alert_banner_secondary.clear_message()
|
|
self.__samcam_feed_banner_active = False
|
|
|
|
def start_text_tutorial(self) -> None:
|
|
self.tutorial_manager.start("manual_workflow_demo")
|
|
|
|
def start_interactive_tutorial(self) -> None:
|
|
self.tutorial_manager.start("manual_workflow_demo")
|
|
|
|
def create_menu_bar(self):
|
|
"""Create a menu bar with File->Quit and Help->About."""
|
|
# Main menu bar
|
|
menu_bar = self.menuBar()
|
|
|
|
# File menu
|
|
file_menu = menu_bar.addMenu("File")
|
|
quit_action = QAction("&Quit", self)
|
|
quit_action.setShortcut(QKeySequence.StandardKey.Quit)
|
|
quit_action.triggered.connect(self.close)
|
|
file_menu.addAction(quit_action)
|
|
|
|
view_menu = menu_bar.addMenu("View")
|
|
|
|
show_samples_action = QAction("Show Sample List", self)
|
|
show_samples_action.setCheckable(True)
|
|
show_samples_action.setChecked(True)
|
|
show_samples_action.triggered.connect(lambda checked: self.tell_samples_dock.setVisible(checked))
|
|
self.tell_samples_dock.visibilityChanged.connect(show_samples_action.setChecked)
|
|
view_menu.addAction(show_samples_action)
|
|
|
|
if self.__decoded_token.staff:
|
|
show_reference_tools_action = QAction("Show Reference Tools", self)
|
|
show_reference_tools_action.setCheckable(True)
|
|
show_reference_tools_action.setChecked(True)
|
|
show_reference_tools_action.triggered.connect(
|
|
lambda checked: self.ref_tools_dock.setVisible(checked)
|
|
)
|
|
self.ref_tools_dock.visibilityChanged.connect(show_reference_tools_action.setChecked)
|
|
view_menu.addAction(show_reference_tools_action)
|
|
|
|
show_job_list_action = QAction("Show job List", self)
|
|
show_job_list_action.setCheckable(True)
|
|
show_job_list_action.setChecked(True)
|
|
show_job_list_action.triggered.connect(lambda checked: self.job_list_dock.setVisible(checked))
|
|
self.job_list_dock.visibilityChanged.connect(show_job_list_action.setChecked)
|
|
view_menu.addAction(show_job_list_action)
|
|
|
|
show_manual_sample_action = QAction("Show manual sample", self)
|
|
show_manual_sample_action.setCheckable(True)
|
|
show_manual_sample_action.setChecked(True)
|
|
show_manual_sample_action.triggered.connect(lambda checked: self.manual_sample_dock.setVisible(checked))
|
|
self.manual_sample_dock.visibilityChanged.connect(show_manual_sample_action.setChecked)
|
|
view_menu.addAction(show_manual_sample_action)
|
|
|
|
show_face_panel_action = QAction("Show face detection", self)
|
|
show_face_panel_action.setCheckable(True)
|
|
show_face_panel_action.setChecked(False)
|
|
show_face_panel_action.triggered.connect(lambda checked: self.face_panel_dock.setVisible(checked))
|
|
self.face_panel_dock.visibilityChanged.connect(show_face_panel_action.setChecked)
|
|
view_menu.addAction(show_face_panel_action)
|
|
|
|
show_fluor_panel_action = QAction("Show fluorescence", self)
|
|
show_fluor_panel_action.setCheckable(True)
|
|
show_fluor_panel_action.setChecked(False)
|
|
show_fluor_panel_action.triggered.connect(lambda checked: self.fluor_panel_dock.setVisible(checked))
|
|
self.fluor_panel_dock.visibilityChanged.connect(show_fluor_panel_action.setChecked)
|
|
view_menu.addAction(show_fluor_panel_action)
|
|
|
|
show_smargon_trace_action = QAction("Show Smargon trace", self)
|
|
show_smargon_trace_action.setCheckable(True)
|
|
show_smargon_trace_action.setChecked(False)
|
|
show_smargon_trace_action.triggered.connect(lambda checked: self.smargon_trace_dock.setVisible(checked))
|
|
self.smargon_trace_dock.visibilityChanged.connect(show_smargon_trace_action.setChecked)
|
|
self.smargon_trace_dock.visibilityChanged.connect(
|
|
lambda visible: self.smargon_trace_panel.refresh_plot(force=True) if visible else None
|
|
)
|
|
view_menu.addAction(show_smargon_trace_action)
|
|
|
|
show_target_stability_action = QAction("Show Target stability", self)
|
|
show_target_stability_action.setCheckable(True)
|
|
show_target_stability_action.setChecked(False)
|
|
show_target_stability_action.triggered.connect(
|
|
lambda checked: self.target_stability_dock.setVisible(checked)
|
|
)
|
|
self.target_stability_dock.visibilityChanged.connect(show_target_stability_action.setChecked)
|
|
view_menu.addAction(show_target_stability_action)
|
|
|
|
show_prediction_metrics_action = QAction("Show Prediction Metrics", self)
|
|
show_prediction_metrics_action.setCheckable(True)
|
|
show_prediction_metrics_action.setChecked(False)
|
|
show_prediction_metrics_action.triggered.connect(
|
|
lambda checked: self.prediction_metrics_dock.setVisible(checked)
|
|
)
|
|
self.prediction_metrics_dock.visibilityChanged.connect(show_prediction_metrics_action.setChecked)
|
|
view_menu.addAction(show_prediction_metrics_action)
|
|
|
|
show_log_action = QAction("Show Log", self)
|
|
show_log_action.setCheckable(True)
|
|
show_log_action.setChecked(False)
|
|
show_log_action.triggered.connect(lambda checked: self.log_dock.setVisible(checked))
|
|
self.log_dock.visibilityChanged.connect(show_log_action.setChecked)
|
|
view_menu.addAction(show_log_action)
|
|
|
|
view_menu.addSeparator()
|
|
|
|
sample_camera_tab_action = QAction("Sample camera tab", self)
|
|
sample_camera_tab_action.setShortcut(QKeySequence("Ctrl+1"))
|
|
sample_camera_tab_action.triggered.connect(lambda: self.video_tab.setCurrentIndex(0))
|
|
view_menu.addAction(sample_camera_tab_action)
|
|
|
|
gonio_camera_tab_action = QAction("Gonio camera tab", self)
|
|
gonio_camera_tab_action.setShortcut(QKeySequence("Ctrl+2"))
|
|
gonio_camera_tab_action.triggered.connect(lambda: self.video_tab.setCurrentIndex(1))
|
|
view_menu.addAction(gonio_camera_tab_action)
|
|
|
|
beamline_view_tab_action = QAction("Beamline view tab", self)
|
|
beamline_view_tab_action.setShortcut(QKeySequence("Ctrl+3"))
|
|
beamline_view_tab_action.triggered.connect(lambda: self.video_tab.setCurrentIndex(2))
|
|
view_menu.addAction(beamline_view_tab_action)
|
|
|
|
beamline_combined_tab_action = QAction("Beamline combined view tab", self)
|
|
beamline_combined_tab_action.setShortcut(QKeySequence("Ctrl+4"))
|
|
beamline_combined_tab_action.triggered.connect(lambda: self.video_tab.setCurrentIndex(3))
|
|
view_menu.addAction(beamline_combined_tab_action)
|
|
|
|
view_menu.addSeparator()
|
|
|
|
restore_default_view_action = QAction("Restore Default View", self)
|
|
restore_default_view_action.setShortcut(QKeySequence("Ctrl+Shift+R"))
|
|
restore_default_view_action.triggered.connect(self.restore_default_view)
|
|
view_menu.addAction(restore_default_view_action)
|
|
|
|
help_menu = menu_bar.addMenu("Help")
|
|
about_action = QAction("About", self)
|
|
about_action.triggered.connect(self.show_about_dialog)
|
|
help_menu.addAction(about_action)
|
|
|
|
controls_help_action = QAction("Mouse / Keyboard Controls", self)
|
|
controls_help_action.setShortcut(QKeySequence(Qt.Key.Key_F1))
|
|
controls_help_action.triggered.connect(self.show_controls_help)
|
|
help_menu.addAction(controls_help_action)
|
|
|
|
dev_help_action = QAction("Developer / Help", self)
|
|
dev_help_action.triggered.connect(self.show_developer_help)
|
|
help_menu.addAction(dev_help_action)
|
|
|
|
if self.__decoded_token.staff:
|
|
beamline_recovery_action = QAction("Beamline Recovery", self)
|
|
beamline_recovery_action.triggered.connect(self.show_beamline_recovery)
|
|
help_menu.addAction(beamline_recovery_action)
|
|
|
|
local_contact_action = QAction("Local Contact", self)
|
|
local_contact_action.triggered.connect(self.show_local_contact)
|
|
help_menu.addAction(local_contact_action)
|
|
|
|
help_menu.addSeparator()
|
|
|
|
start_text_tutorial_action = QAction("Start Tutorial (Text)", self)
|
|
start_text_tutorial_action.triggered.connect(self.start_text_tutorial)
|
|
help_menu.addAction(start_text_tutorial_action)
|
|
|
|
start_interactive_tutorial_action = QAction("Start Tutorial (Interactive)", self)
|
|
start_interactive_tutorial_action.triggered.connect(self.start_interactive_tutorial)
|
|
help_menu.addAction(start_interactive_tutorial_action)
|
|
|
|
def _capture_default_window_state(self) -> None:
|
|
self._default_window_state = self.saveState()
|
|
|
|
@Slot()
|
|
def restore_default_view(self) -> None:
|
|
if self._default_window_state is not None:
|
|
self.restoreState(self._default_window_state)
|
|
|
|
self.tell_samples_dock.setVisible(True)
|
|
self.job_list_dock.setVisible(True)
|
|
self.manual_sample_dock.setVisible(True)
|
|
|
|
self.face_panel_dock.setVisible(False)
|
|
self.fluor_panel_dock.setVisible(False)
|
|
self.smargon_trace_dock.setVisible(False)
|
|
self.target_stability_dock.setVisible(False)
|
|
self.prediction_metrics_dock.setVisible(False)
|
|
self.log_dock.setVisible(False)
|
|
|
|
if self.__decoded_token.staff:
|
|
self.ref_tools_dock.setVisible(True)
|
|
self.ref_tools_dock.raise_()
|
|
else:
|
|
self.ref_tools_dock.setVisible(False)
|
|
self.tell_samples_dock.raise_()
|
|
|
|
self.video_tab.setCurrentIndex(0)
|
|
|
|
def show_about_dialog(self):
|
|
QMessageBox.about(
|
|
self,
|
|
"About",
|
|
"Aare Macromolecular Crystallography GUI\nVersion: 0.3.1\nCopyright: Paul Scherrer Institute 2024-2026",
|
|
)
|
|
|
|
def show_controls_help(self) -> None:
|
|
if self._controls_help_dialog is None:
|
|
self._controls_help_dialog = ControlsHelpDialog(parent=self)
|
|
self._controls_help_dialog.show()
|
|
self._controls_help_dialog.raise_()
|
|
self._controls_help_dialog.activateWindow()
|
|
|
|
def show_developer_help(self) -> None:
|
|
if self._dev_help_dialog is None:
|
|
self._dev_help_dialog = DeveloperHelpDialog(
|
|
daq=self.daq,
|
|
is_staff=bool(getattr(self.__decoded_token, "staff", False)),
|
|
parent=self,
|
|
)
|
|
self._dev_help_dialog.refresh()
|
|
self._dev_help_dialog.show()
|
|
self._dev_help_dialog.raise_()
|
|
self._dev_help_dialog.activateWindow()
|
|
|
|
def _clear_automation_critical_banner(self) -> None:
|
|
if not self._automation_critical_banner_active:
|
|
return
|
|
self.alert_banner.clear_message()
|
|
self._automation_critical_banner_active = False
|
|
|
|
@Slot(bool)
|
|
def _on_automation_running_changed(self, running: bool) -> None:
|
|
if running:
|
|
self._clear_automation_critical_banner()
|
|
|
|
def _is_detector_critical_failure(self, message: str) -> bool:
|
|
text = (message or "").lower()
|
|
return "detector" in text or "jfjoch" in text
|
|
|
|
@staticmethod
|
|
def _is_detector_state_error(message: str) -> bool:
|
|
text = (message or "").lower()
|
|
return (
|
|
"daq state error" in text
|
|
or "must be idle to start measurement" in text
|
|
or "must be idle" in text
|
|
)
|
|
|
|
def _detector_error_dialog_title(self, message: str) -> str:
|
|
if self._is_detector_state_error(message):
|
|
return "Detector state error"
|
|
return "Detector error"
|
|
|
|
def _detector_error_banner_text(self, *, automation: bool, message: str) -> str:
|
|
if self._is_detector_state_error(message):
|
|
prefix = "Automation halted" if automation else "Manual collection stopped"
|
|
return f"{prefix}: detector state error."
|
|
return (
|
|
"Automation halted: detector error."
|
|
if automation
|
|
else "Manual collection stopped: detector error."
|
|
)
|
|
|
|
@Slot(str)
|
|
def _on_manual_collection_critical_failure(self, message: str) -> None:
|
|
logger.critical(f"Manual collection critical detector failure: {message}")
|
|
|
|
try:
|
|
self.alert_banner_secondary.show_message(
|
|
self._detector_error_banner_text(automation=False, message=message),
|
|
True,
|
|
auto_clear_ms=0,
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
QMessageBox.critical(
|
|
self,
|
|
self._detector_error_dialog_title(message),
|
|
(
|
|
"The manual collection has stopped because there is an error with the detector.\n\n"
|
|
"Please call your local contact.\n\n"
|
|
f"Details:\n{message}"
|
|
),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"Failed to show manual collection detector popup: {e}")
|
|
|
|
@Slot(str)
|
|
def _on_automation_critical_failure(self, message: str) -> None:
|
|
"""
|
|
Hard-stop handler for fatal automation failures coming from the server
|
|
(transformation errors, busy-flag corruption, unhandled 500s on /scan/auto).
|
|
|
|
Stops the queue, marks the progress widget as failed and surfaces the
|
|
beamline recovery dialog (staff) or a critical error message (users).
|
|
"""
|
|
logger.critical(f"Automation critical failure: {message}")
|
|
|
|
is_detector_failure = self._is_detector_critical_failure(message)
|
|
banner_message = (
|
|
self._detector_error_banner_text(automation=True, message=message)
|
|
if is_detector_failure
|
|
else f"Automation halted: {message}"
|
|
)
|
|
|
|
# 1. Stop the sample queue so we don't keep dispatching new samples
|
|
try:
|
|
if self.job_list_panel is not None and self.job_list_panel.is_running():
|
|
self.job_list_panel.pause_automation()
|
|
if self.daq is not None:
|
|
self.daq.send_status_request()
|
|
except Exception as e:
|
|
logger.error(f"Failed to pause automation queue after critical failure: {e}")
|
|
|
|
# 2. Mark the automation progress widget as finished-with-error so
|
|
# _is_automation_active() returns False and idle/close timers behave.
|
|
try:
|
|
from aare.common.automation_models import (
|
|
AutomationProgress,
|
|
StepState,
|
|
StepStatus,
|
|
WorkflowStateKind,
|
|
)
|
|
progress = getattr(self.automation_progress_panel, "_progress", None)
|
|
if progress is None:
|
|
progress = AutomationProgress(
|
|
current_step=None,
|
|
steps=[
|
|
StepState(step=WorkflowStateKind.MOUNT, status=StepStatus.PENDING),
|
|
StepState(step=WorkflowStateKind.LOOP_CENTRE, status=StepStatus.PENDING),
|
|
StepState(step=WorkflowStateKind.RASTER, status=StepStatus.PENDING),
|
|
StepState(step=WorkflowStateKind.DATA_COLLECTION, status=StepStatus.PENDING),
|
|
StepState(step=WorkflowStateKind.FINAL, status=StepStatus.PENDING),
|
|
],
|
|
finished=False,
|
|
success=None,
|
|
)
|
|
for step in progress.steps:
|
|
if step.status == StepStatus.RUNNING:
|
|
step.status = StepStatus.FAILED
|
|
step.message = message
|
|
if step.step == WorkflowStateKind.FINAL:
|
|
step.status = StepStatus.FAILED
|
|
step.message = message
|
|
progress.finished = True
|
|
progress.success = False
|
|
self.automation_progress_panel.set_progress(progress)
|
|
except Exception as e:
|
|
logger.error(f"Failed to update automation progress after critical failure: {e}")
|
|
|
|
# 3. Banner so the operator sees it immediately
|
|
try:
|
|
self.alert_banner.show_message(
|
|
banner_message, True, auto_clear_ms=0
|
|
)
|
|
self._automation_critical_banner_active = True
|
|
except Exception:
|
|
pass
|
|
|
|
# 4. Surface recovery UI
|
|
try:
|
|
if bool(getattr(self.__decoded_token, "staff", False)):
|
|
if is_detector_failure:
|
|
QMessageBox.critical(
|
|
self,
|
|
self._detector_error_dialog_title(message),
|
|
(
|
|
"Automation has been stopped because there is an error with the detector.\n\n"
|
|
"Please call your local contact.\n\n"
|
|
f"Details:\n{message}"
|
|
),
|
|
)
|
|
self.show_local_contact("Detector")
|
|
else:
|
|
self.show_local_contact("Recovery")
|
|
else:
|
|
if is_detector_failure:
|
|
QMessageBox.critical(
|
|
self,
|
|
self._detector_error_dialog_title(message),
|
|
(
|
|
"Automation has been stopped because there is an error with the detector.\n\n"
|
|
"Please call your local contact.\n\n"
|
|
f"Details:\n{message}"
|
|
),
|
|
)
|
|
else:
|
|
QMessageBox.critical(
|
|
self,
|
|
"Automation halted",
|
|
(
|
|
"A critical error occurred during automation and the "
|
|
"beamline could not recover automatically:\n\n"
|
|
f"{message}\n\n"
|
|
"Please contact your local contact to recover the beamline."
|
|
),
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"Failed to surface recovery UI after critical failure: {e}")
|
|
|
|
def show_beamline_recovery(self) -> None:
|
|
if not bool(getattr(self.__decoded_token, "staff", False)):
|
|
return
|
|
if self._beamline_recovery_dialog is None:
|
|
self._beamline_recovery_dialog = BeamlineRecoveryDialog(
|
|
daq=self.daq,
|
|
parent=self,
|
|
)
|
|
self._beamline_recovery_dialog.show()
|
|
self._beamline_recovery_dialog.raise_()
|
|
self._beamline_recovery_dialog.activateWindow()
|
|
|
|
def show_local_contact(self, tab_name: str = "Recovery") -> None:
|
|
if not bool(getattr(self.__decoded_token, "staff", False)):
|
|
return
|
|
if self._local_contact_dialog is None:
|
|
self._local_contact_dialog = LocalContactDialog(
|
|
daq=self.daq,
|
|
parent=self,
|
|
)
|
|
self._local_contact_dialog.set_active_tab(tab_name)
|
|
self._local_contact_dialog.show()
|
|
self._local_contact_dialog.raise_()
|
|
self._local_contact_dialog.activateWindow()
|
|
|
|
@Slot(str)
|
|
def show_sample_missing_dialog(self, msg: str):
|
|
if self.job_list_panel.is_running():
|
|
logger.warning(f"Automation: Sample missing: {msg}")
|
|
return
|
|
QMessageBox.warning(self, "No Sample", f"{msg}")
|
|
|
|
#TODO tidy up mount and sampel view fucntions
|
|
@Slot()
|
|
def mount_view(self):
|
|
self.video_tab.setCurrentIndex(3)
|
|
|
|
@Slot()
|
|
def sample_view(self):
|
|
self.video_tab.setCurrentIndex(0)
|
|
|
|
@Slot(DAQStatusModel)
|
|
def update_daq_status(self, s: DAQStatusModel):
|
|
self._latest_daq_status = s
|
|
|
|
if self._is_automation_active():
|
|
self._refresh_idle_activity(report_backend=False)
|
|
|
|
if hasattr(self, "beamline_camera_thread") and self.beamline_camera_thread is not None:
|
|
self.beamline_camera_thread.set_busy(s.busy)
|
|
|
|
if hasattr(self, "gonio_camera_thread") and self.gonio_camera_thread is not None:
|
|
self.gonio_camera_thread.set_busy(s.busy)
|
|
|
|
self.target_stability_panel.set_beam_center(
|
|
s.geom.beam_location_pxl.x,
|
|
s.geom.beam_location_pxl.y,
|
|
)
|
|
|
|
current_session = int(getattr(self.__decoded_token, "session", -1))
|
|
for gui in getattr(s, "open_guis", []) or []:
|
|
try:
|
|
if int(gui.session) == current_session and bool(gui.close_requested):
|
|
if self._remote_close_deadline_ts is None:
|
|
self._start_remote_close_countdown(
|
|
requested_by=gui.close_requested_by,
|
|
grace_seconds=gui.close_grace_seconds,
|
|
)
|
|
break
|
|
except Exception:
|
|
continue
|
|
else:
|
|
if self._remote_close_deadline_ts is not None:
|
|
self._clear_remote_close_request()
|
|
|
|
if not self.__mounting and s.state == BeamlineStateEnum.RobotSampleExchange:
|
|
self.__mounting = True
|
|
self.video_tab.setCurrentIndex(3)
|
|
elif self.__mounting and s.state != BeamlineStateEnum.RobotSampleExchange:
|
|
self.__mounting = False
|
|
self.video_tab.setCurrentIndex(0)
|
|
|
|
|
|
# ========== BATON DIALOG HANDLING ==========
|
|
|
|
@Slot(dict)
|
|
def _show_baton_request_dialog(self, payload: dict):
|
|
logger.info(f"Showing baton request dialog with payload: {payload}")
|
|
requester = str(payload.get("requester") or "Another user")
|
|
timeout = int(payload.get("timeout") or 30)
|
|
|
|
if self._baton_request_dialog is not None:
|
|
if self._baton_request_dialog.isVisible():
|
|
logger.debug("Baton request dialog already visible, skipping")
|
|
return
|
|
else:
|
|
logger.debug("Baton request dialog exists but not visible, recreating")
|
|
self._baton_request_dialog.close()
|
|
self._baton_request_dialog = None
|
|
|
|
self._baton_request_dialog = BatonRequestDialog(
|
|
requester=requester,
|
|
timeout_seconds=timeout,
|
|
parent=self,
|
|
)
|
|
self._baton_request_dialog.accepted_signal.connect(self.status_bar._on_baton_dialog_accepted)
|
|
self._baton_request_dialog.refused_signal.connect(self.status_bar._on_baton_dialog_refused)
|
|
self._baton_request_dialog.show()
|
|
self._baton_request_dialog.raise_()
|
|
self._baton_request_dialog.activateWindow()
|
|
logger.info("Baton request dialog shown")
|
|
|
|
@Slot()
|
|
def _accept_baton_request(self):
|
|
self.daq.respond_to_baton_request(True)
|
|
|
|
@Slot()
|
|
def _refuse_baton_request(self):
|
|
self.daq.respond_to_baton_request(False)
|
|
|
|
@Slot(BatonStatus)
|
|
def _on_baton_status_changed(self, status: BatonStatus):
|
|
"""
|
|
Update waiting UI based on SSE status.
|
|
StatusBar handles baton-granted p-group selection automatically.
|
|
"""
|
|
if self._waiting_for_baton_response and not status.you_have_pending_request:
|
|
self._waiting_for_baton_response = False
|
|
self._close_baton_pending_dialog()
|
|
|
|
if status.you_are_holder:
|
|
self.alert_banner.show_message("Baton acquired!", False, auto_clear_ms=10000)
|
|
else:
|
|
self.alert_banner.show_message("Request declined or cancelled", False, auto_clear_ms=10000)
|
|
|
|
# Manage incoming request dialog (when someone requests from us)
|
|
if not status.incoming_request and self._baton_request_dialog is not None:
|
|
logger.info("Incoming baton request no longer active, closing request dialog")
|
|
self._close_baton_dialog()
|
|
|
|
@Slot(dict)
|
|
def _on_baton_request_result(self, result: dict):
|
|
"""
|
|
Handle result of our baton request.
|
|
- Show success/pending/error banners
|
|
- Manage pending dialog lifecycle
|
|
- StatusBar handles p-group selection automatically via update_baton_status
|
|
"""
|
|
if result.get("granted"):
|
|
self._waiting_for_baton_response = False
|
|
self.alert_banner.show_message("Baton acquired!", False, auto_clear_ms=10000)
|
|
logger.info("Baton acquired")
|
|
# Close pending dialog; StatusBar will trigger p-group selection via SSE
|
|
self._close_baton_pending_dialog()
|
|
|
|
elif result.get("pending"):
|
|
self._waiting_for_baton_response = True
|
|
timeout = result.get("timeout_seconds", 30)
|
|
holder = result.get("message", "Waiting for response...")
|
|
is_busy = result.get("beamline_busy", False)
|
|
|
|
if getattr(self, "_baton_pending_dialog", None) is None:
|
|
target_user = holder.replace("Request sent to ", "").replace(
|
|
" (Note: beamline is currently busy, transfer will be queued if accepted)", "")
|
|
self._baton_pending_dialog = BatonPendingDialog(target_user=target_user, timeout_seconds=timeout,
|
|
parent=self)
|
|
self._baton_pending_dialog.cancelled_signal.connect(self.daq.cancel_baton_request)
|
|
self._baton_pending_dialog.show()
|
|
else:
|
|
self._baton_pending_dialog.update_remaining(timeout)
|
|
|
|
self.alert_banner.show_waiting(f"Requesting control - {holder}", timeout)
|
|
logger.info(f"Baton request pending - {timeout}s timeout (busy={is_busy})")
|
|
|
|
elif result.get("queued"):
|
|
self._waiting_for_baton_response = True
|
|
self.alert_banner.show_waiting("Control transfer queued - waiting for beamline")
|
|
logger.info("Baton transfer queued")
|
|
|
|
if getattr(self, "_baton_pending_dialog", None) is None:
|
|
self._baton_pending_dialog = BatonPendingDialog(target_user="Current Holder", timeout_seconds=0,
|
|
parent=self)
|
|
self._baton_pending_dialog.cancelled_signal.connect(self.daq.cancel_baton_request)
|
|
self._baton_pending_dialog.show()
|
|
self._baton_pending_dialog.set_queued_state()
|
|
|
|
elif result.get("already_holder"):
|
|
self._waiting_for_baton_response = False
|
|
logger.debug("Already baton holder")
|
|
self._close_baton_pending_dialog()
|
|
|
|
elif result.get("error"):
|
|
self._waiting_for_baton_response = False
|
|
self.alert_banner.show_message(result.get("message", "Request failed"), True,
|
|
auto_clear_ms=15000)
|
|
logger.warning(f"Baton request failed: {result.get('message')}")
|
|
self._close_baton_pending_dialog()
|
|
|
|
@Slot(dict)
|
|
def _on_baton_response_result(self, result: dict):
|
|
"""
|
|
Handle response after someone requests from us.
|
|
Just update UI banners; StatusBar handles session display.
|
|
"""
|
|
logger.debug(f"Baton response result: {result}")
|
|
if result.get("accepted"):
|
|
self._waiting_for_baton_response = False
|
|
self.alert_banner.show_message("Control transferred", False, auto_clear_ms=10000)
|
|
self._close_baton_dialog()
|
|
self.status_bar.update_baton_status(self.status_bar._baton_status)
|
|
elif result.get("refused"):
|
|
self._waiting_for_baton_response = False
|
|
self.alert_banner.show_message("Request declined", False, auto_clear_ms=10000)
|
|
self._close_baton_dialog()
|
|
self.status_bar.update_baton_status(self.status_bar._baton_status)
|
|
else:
|
|
logger.debug(f"replied with {result}")
|
|
|
|
@Slot(dict)
|
|
def _on_baton_timeout_checked(self, result: dict):
|
|
"""Refresh waiting UI when backend confirms timeout state."""
|
|
logger.debug(f"Baton timeout checked: {result}")
|
|
if result.get("pending"):
|
|
remaining = int(result.get("remaining_seconds", 0))
|
|
if self._waiting_for_baton_response:
|
|
self.alert_banner.show_waiting("Requesting control", remaining)
|
|
if getattr(self, "_baton_pending_dialog", None) is not None:
|
|
self._baton_pending_dialog.update_remaining(remaining)
|
|
|
|
elif result.get("granted"):
|
|
self._waiting_for_baton_response = False
|
|
self.alert_banner.show_message("Baton acquired!", False, auto_clear_ms=10000)
|
|
self._close_baton_pending_dialog()
|
|
|
|
elif result.get("queued"):
|
|
self._waiting_for_baton_response = True
|
|
self.alert_banner.show_waiting("Control transfer queued - waiting for beamline")
|
|
|
|
if getattr(self, "_baton_pending_dialog", None) is not None:
|
|
self._baton_pending_dialog.set_queued_state()
|
|
else:
|
|
self._baton_pending_dialog = BatonPendingDialog(target_user="Current Holder", timeout_seconds=0,
|
|
parent=self)
|
|
self._baton_pending_dialog.cancelled_signal.connect(self.daq.cancel_baton_request)
|
|
self._baton_pending_dialog.show()
|
|
self._baton_pending_dialog.set_queued_state()
|
|
|
|
elif result.get("refused"):
|
|
self._waiting_for_baton_response = False
|
|
self.alert_banner.show_message("Request declined", False, auto_clear_ms=10000)
|
|
self._close_baton_pending_dialog()
|
|
|
|
else:
|
|
logger.debug(f"replied with {result}")
|
|
self.alert_banner.clear_message()
|
|
self._close_baton_pending_dialog()
|
|
|
|
def _close_baton_dialog(self) -> None:
|
|
"""Close the incoming-request dialog (when someone requests from us)."""
|
|
if getattr(self, "_baton_request_dialog", None) is not None:
|
|
try:
|
|
self._baton_request_dialog.close()
|
|
finally:
|
|
self._baton_request_dialog = None
|
|
|
|
def _close_baton_pending_dialog(self) -> None:
|
|
if getattr(self, "_baton_pending_dialog", None) is not None:
|
|
try:
|
|
if hasattr(self._baton_pending_dialog, '_timer'):
|
|
self._baton_pending_dialog._timer.stop()
|
|
self._baton_pending_dialog.close()
|
|
finally:
|
|
self._baton_pending_dialog = None
|
|
|
|
def _save_panel_visibility_settings(self) -> None:
|
|
"""Save visibility state for developer/diagnostic panels."""
|
|
settings = QSettings("PSI", "AareGUI")
|
|
settings.beginGroup("panel_visibility")
|
|
settings.setValue("smargon_trace", self.smargon_trace_dock.isVisible())
|
|
settings.setValue("target_stability", self.target_stability_dock.isVisible())
|
|
settings.setValue("prediction_metrics", self.prediction_metrics_dock.isVisible())
|
|
settings.setValue("face_detection", self.face_panel_dock.isVisible())
|
|
settings.setValue("fluorescence", self.fluor_panel_dock.isVisible())
|
|
settings.setValue("log", self.log_dock.isVisible())
|
|
settings.endGroup()
|
|
|
|
def _restore_panel_visibility_settings(self) -> None:
|
|
"""Restore visibility state for developer/diagnostic panels."""
|
|
settings = QSettings("PSI", "AareGUI")
|
|
settings.beginGroup("panel_visibility")
|
|
|
|
if settings.contains("smargon_trace"):
|
|
self.smargon_trace_dock.setVisible(settings.value("smargon_trace", False, type=bool))
|
|
if settings.contains("target_stability"):
|
|
self.target_stability_dock.setVisible(settings.value("target_stability", False, type=bool))
|
|
if settings.contains("prediction_metrics"):
|
|
self.prediction_metrics_dock.setVisible(settings.value("prediction_metrics", False, type=bool))
|
|
if settings.contains("face_detection"):
|
|
self.face_panel_dock.setVisible(settings.value("face_detection", False, type=bool))
|
|
if settings.contains("fluorescence"):
|
|
self.fluor_panel_dock.setVisible(settings.value("fluorescence", False, type=bool))
|
|
if settings.contains("log"):
|
|
self.log_dock.setVisible(settings.value("log", False, type=bool))
|
|
|
|
settings.endGroup()
|
|
|
|
def _restore_window_state(self) -> None:
|
|
#TODO put all setting related handlign into state_manager
|
|
self.state_manager.restore_window(self)
|
|
self._restore_panel_visibility_settings()
|
|
|
|
def closeEvent(self, event) -> None:
|
|
try:
|
|
# TODO put all setting related handling into state_manager
|
|
self.state_manager.save_window(self)
|
|
self._save_samcam_overlay_settings()
|
|
self._save_panel_visibility_settings()
|
|
|
|
except Exception as e:
|
|
logger.warning(f"Failed to save main window state: {e}")
|
|
|
|
# End session before closing so the backend removes this GUI from Redis immediately
|
|
try:
|
|
self.daq.end_session_on_close()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to end session on close: {e}")
|
|
|
|
try:
|
|
self.cleanup()
|
|
except Exception as e:
|
|
logger.warning(f"Cleanup during closeEvent failed: {e}")
|
|
|
|
super().closeEvent(event)
|
|
|
|
def cleanup(self):
|
|
if getattr(self, "_cleanup_done", False):
|
|
return
|
|
self._cleanup_done = True
|
|
|
|
try:
|
|
if hasattr(self, "_samcam_source_timer") and self._samcam_source_timer is not None:
|
|
self._samcam_source_timer.stop()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to stop _samcam_source_timer: {e}")
|
|
|
|
try:
|
|
if hasattr(self, "_idle_timer") and self._idle_timer is not None:
|
|
self._idle_timer.stop()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to stop _idle_timer: {e}")
|
|
|
|
try:
|
|
if hasattr(self, "_remote_close_timer") and self._remote_close_timer is not None:
|
|
self._remote_close_timer.stop()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to stop _remote_close_timer: {e}")
|
|
|
|
try:
|
|
if hasattr(self, "daq") and self.daq is not None:
|
|
self.daq.cleanup()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to clean up DAQ worker: {e}")
|
|
|
|
for attr_name in (
|
|
"camera_thread",
|
|
"prediction_thread",
|
|
"beamline_camera_thread",
|
|
"gonio_camera_thread",
|
|
):
|
|
thread = getattr(self, attr_name, None)
|
|
if thread is None:
|
|
continue
|
|
|
|
logger.debug(f"Stopping {attr_name}")
|
|
|
|
try:
|
|
thread.stop()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to stop {attr_name}: {e}")
|
|
|
|
setattr(self, attr_name, None)
|
|
|
|
def _is_automation_active(self) -> bool:
|
|
try:
|
|
if hasattr(self, "job_list_panel") and self.job_list_panel is not None:
|
|
return bool(self.job_list_panel.is_running())
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
progress = getattr(self.automation_progress_panel, "_progress", None)
|
|
if progress is not None and not bool(getattr(progress, "finished", False)):
|
|
return True
|
|
except Exception:
|
|
pass
|
|
|
|
return False
|
|
|
|
def _refresh_idle_activity(self, *, report_backend: bool = False) -> None:
|
|
self._last_user_interaction_ts = time.time()
|
|
|
|
if not report_backend:
|
|
return
|
|
|
|
now = time.monotonic()
|
|
if now - self._last_interaction_report_ts < self._interaction_report_min_interval_s:
|
|
return
|
|
|
|
self._last_interaction_report_ts = now
|
|
try:
|
|
self.daq.report_gui_interaction(int(self.__decoded_token.session))
|
|
except Exception as e:
|
|
logger.debug(f"Failed to report GUI interaction: {e}")
|
|
|
|
def _mark_user_interaction(self) -> None:
|
|
self._refresh_idle_activity(report_backend=True)
|
|
|
|
def eventFilter(self, obj, event):
|
|
try:
|
|
if event is not None and event.type() in {
|
|
QEvent.Type.MouseButtonPress,
|
|
QEvent.Type.MouseButtonRelease,
|
|
QEvent.Type.MouseMove,
|
|
QEvent.Type.Wheel,
|
|
QEvent.Type.KeyPress,
|
|
QEvent.Type.KeyRelease,
|
|
QEvent.Type.FocusIn,
|
|
QEvent.Type.TouchBegin,
|
|
QEvent.Type.TouchUpdate,
|
|
}:
|
|
self._mark_user_interaction()
|
|
except Exception as e:
|
|
logger.debug(f"GUI interaction event filter error: {e}")
|
|
return super().eventFilter(obj, event)
|
|
|
|
def _start_remote_close_countdown(self, requested_by: str | None, grace_seconds: int | None) -> None:
|
|
grace = max(1, int(grace_seconds or 60))
|
|
self._remote_close_deadline_ts = time.time() + grace
|
|
self._remote_close_reason = requested_by or "staff"
|
|
self._remote_close_timer.start()
|
|
|
|
self.alert_banner_secondary.show_message(
|
|
f"GUI close requested by {self._remote_close_reason}. Closing in {grace}s when safe.",
|
|
True,
|
|
)
|
|
self._remote_close_banner_active = True
|
|
|
|
def _clear_remote_close_request(self) -> None:
|
|
self._remote_close_deadline_ts = None
|
|
self._remote_close_reason = None
|
|
self._remote_close_timer.stop()
|
|
if self._remote_close_banner_active:
|
|
self.alert_banner_secondary.clear_message()
|
|
self._remote_close_banner_active = False
|
|
|
|
def _can_close_for_idle_or_remote(self) -> bool:
|
|
status = self._latest_daq_status
|
|
if status is not None and bool(status.busy):
|
|
return False
|
|
if self._is_automation_active():
|
|
return False
|
|
return True
|
|
|
|
@Slot()
|
|
def _check_remote_close_deadline(self) -> None:
|
|
if self._remote_close_deadline_ts is None:
|
|
return
|
|
|
|
remaining = int(round(self._remote_close_deadline_ts - time.time()))
|
|
if remaining > 0:
|
|
if self._remote_close_banner_active:
|
|
self.alert_banner_secondary.show_message(
|
|
f"GUI close requested by {self._remote_close_reason or 'staff'}. Closing in {remaining}s when safe.",
|
|
True,
|
|
)
|
|
return
|
|
|
|
if not self._can_close_for_idle_or_remote():
|
|
if self._remote_close_banner_active:
|
|
self.alert_banner_secondary.show_message(
|
|
"GUI close requested, waiting for beamline/automation to become idle.",
|
|
True,
|
|
)
|
|
return
|
|
|
|
logger.warning("Closing GUI due to remote close request.")
|
|
self.close()
|
|
|
|
@Slot()
|
|
def _check_idle_timeout(self) -> None:
|
|
idle_for_s = time.time() - self._last_user_interaction_ts
|
|
if idle_for_s < self._idle_close_timeout_s:
|
|
return
|
|
|
|
if not self._can_close_for_idle_or_remote():
|
|
logger.info("Idle timeout reached, but GUI remains open because beamline is busy or automation is active.")
|
|
return
|
|
|
|
logger.warning("Closing GUI after inactivity timeout.")
|
|
self.close() |