Index: shared/scripts/names.py =================================================================== diff -u -r36a57fc3f2c136f17a1f75d40a69bf06f2532d27 -r310f51a5ed4921f184572f90d07b350ec41c0bae --- shared/scripts/names.py (.../names.py) (revision 36a57fc3f2c136f17a1f75d40a69bf06f2532d27) +++ shared/scripts/names.py (.../names.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -167,6 +167,7 @@ o_poweroff_notification = {"container": o_Overlay , "id": "_titleText" , "type": "TitleText" , "unnamed": 1, "visible": True, "type": "Text", "text": "System is shutting down"} o_poweroff_rejection = {"container": o_Overlay , "id": "_titleText" , "type": "TitleText" , "unnamed": 1, "visible": True, "type": "Text"} o_settings_end_treatment = {"container": o_QQuickView , "objectName": "_endTreatmentButton", "type": "TouchRect"} +o_settings_clear_alarm_condition = {"container": o_QQuickView , "objectName": "_clearAlarmCondition", "type": "TouchRect"} # Main Treatment Screen o_treatmentStart_TreatmentStart = {"container": o_QQuickView, "id": "_treatmentStart", "type": "TreatmentStart", "unnamed": 1, "visible": True} @@ -230,9 +231,19 @@ o_alarm_bar_maximize = {"container": o_alarm_bar , "id" : "_updownButton" , "type": "UpDownButton" } o_qquickview_alarm = {"type": "QQuickView", "unnamed": 1, "visible": True} -o_okay_alarm = {"container": o_Overlay, "id": "_okay", "type": "TouchRect", "unnamed": 1, "visible": True} + +o_alarm_dialog = {"container": o_Overlay, "id": "_backgroundRect", "type": "Rectangle", "unnamed": 1, "visible": True} +o_okay_alarm = {"container": o_Overlay, "objectName": "_alarmOK", "type": "TouchRect"} +# o_okay_alarm = {"container": o_Overlay, "id": "_okay", "type": "TouchRect", "unnamed": 1, "visible": True} + +o_alarm_resume = {"container": o_Overlay, "objectName": "_alarmResume", "type": "TouchRect"} +o_alarm_rinseback = {"container": o_Overlay, "objectName": "_alarmRinseback", "type": "TouchRect"} +o_alarm_end = {"container": o_Overlay, "objectName": "_alarmEnd", "type": "TouchRect"} +o_alarm_bar = {"container": o_qquickview_alarm, "objectName": "NotificationBar", "type": "NotificationBar"} +o_alarm_mute_button = {"container": o_Overlay, "objectName": "_alarmMuteButton", "type": "MuteButton"} +o_alarm_silence_expires = {"container": o_Overlay, "objectName": "_TimeText", "type": "TimeText"} + o_treatmentStart_heparinTouchArea_TreatmentFluid = {"container": o_treatmentStart_TreatmentStart, "id": "_heparinTouchArea", "type": "TreatmentFluid", "unnamed": 1, "visible": True} -o_dismiss_alarm = {"container": o_Overlay, "id": "_silence", "type": "TouchRect", "unnamed": 1, "visible": True} o_treatmentStart_TimeText_TimeText = {"container": o_treatmentStart_TreatmentStart, "objectName": "_TimeText", "type": "TimeText", "visible": True} o_treatmentStart_TimeText_hour_Text = {"container": o_treatmentStart_TreatmentStart, "objectName": "_TimeText_hour", "type": "Text", "visible": True} o_treatmentStart_TimeText_minute_Text = {"container": o_treatmentStart_TreatmentStart, "objectName": "_TimeText_minute", "type": "Text", "visible": True} @@ -462,9 +473,14 @@ # Alarm System o_NotificationDialog_OKAY = {"container": o_Overlay, "text": "OKAY", "type": "Text"} +# Alert System +o_alert = {"container": o_Overlay, "id": "_backgroundRect", "type": "Rectangle"} +o_alert_confirm = {"container": o_Overlay, "objectName": "AlertConfirmButton", "type": "TouchRect"} +o_alert_cancel = {"container": o_Overlay, "objectName": "AlertCancelButton", "type": "TouchRect"} + o_create_treatment_button = {"container": o_treatmentHome, "text": "CREATE TREATMENT", "type": "Text", "unnamed": 1 } o_create_treatment_container = {"container": o_qquickview_alarm, "objectName": "TreatmentCreate", "type": "TreatmentCreate" } -o_create_treatment_flickable = {"container": o_create_treatment_container, "objectName": "TreatmentCreateFlickable", "type": "Flickable"} +o_create_treatment_flickable = {"container": o_create_treatment_container, "objectName": "_treatmentCreateFlickable", "type": "Flickable"} o_create_treatment_saline_bolus_0 = {"container": o_create_treatment_container, "objectName": "_salineBolusRect0", "type": "TouchRect"} o_create_treatment_saline_bolus_1 = {"container": o_create_treatment_container, "objectName": "_salineBolusRect1", "type": "TouchRect"} o_create_treatment_saline_bolus_2 = {"container": o_create_treatment_container, "objectName": "_salineBolusRect2", "type": "TouchRect"} @@ -484,6 +500,11 @@ o_create_treatment_confirm = {"container": o_create_treatment_confirm_container, "objectName": "_continueRect", "type": "TouchRect"} o_create_treatment_confirm_back_button = {"container": o_create_treatment_confirm_container, "objectName": "_backButton", "type": "BackButton"} +o_create_treatment_arterial_column = {"container": o_create_treatment_container, "objectName": "_arterialPressureLimitsColumn", "type": "Column" } +o_create_treatment_arterial_slider = {"container": o_create_treatment_container, "objectName": "_arterialPressureLimitsSlider", "type": "RangeSlider" } +o_create_treatment_venous_column = {"container": o_create_treatment_container, "objectName": "_venousPressureLimitsColumn", "type": "Column" } +o_create_treatment_venous_slider = {"container": o_create_treatment_container, "objectName": "_venousPressureLimitsSlider", "type": "RangeSlider" } + # Confirm + Priming + Begin Treatment o_confirm_treatment_flickable = {"container": o_create_treatment_confirm_container, "objectName": "_treatmentConfirmFlickable", "type": "Flickable"} o_priming_container = {"container": o_qquickview_alarm, "objectName": "_treatmentPrime", "type": "TreatmentPrime"} @@ -492,6 +513,5 @@ o_priming_continue_button = {"container": o_priming_container, "objectName": "_treatmentPrimeContinueButton", "type": "TouchRect"} o_treatment_begin_container = {"container": o_qquickview_alarm, "objectName": "_treatmentBegin", "type": "TreatmentBegin"} o_treatment_begin_flickable = {"container": o_treatment_begin_container, "objectName": "_treatmentBeginFlickable", "type": "TreatmentBegin"} -o_treatment_begin_start_button = {"container": o_treatment_begin_container, "objectName": "_treatmentBeginStart", "type": "TouchRect"} +o_treatment_begin_start_button = {"container": o_treatment_begin_container, "objectName": "_treatmentBeginStartButton", "type": "TouchRect"} o_treatment_begin_back_button = {"container": o_treatment_begin_container, "objectName": "_backButton", "type": "BackButton"} - Index: simulator/plugins/alarms/loader.py =================================================================== diff -u --- simulator/plugins/alarms/loader.py (revision 0) +++ simulator/plugins/alarms/loader.py (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -0,0 +1,330 @@ +""" + The Alarms ui loader class container file +""" +import os +from simulator.dynamicloader import DynamicLoader +from PySide2 import QtWidgets +from PySide2.QtCore import Slot, QObject, Qt +from datetime import datetime +from dialin.common.prs_defs import AlarmPriority + + +class Loader(DynamicLoader): + """ + The Alarms ui loader class + """ + + canMaximize = True + + btnTrigger: QtWidgets.QPushButton + btnClear: QtWidgets.QPushButton + btnCondition: QtWidgets.QPushButton + spnAlarmID: QtWidgets.QSpinBox + tblStatusIDs: QtWidgets.QTableWidget + + btnSend: QtWidgets.QPushButton + btnMute: QtWidgets.QPushButton + spnTopID: QtWidgets.QSpinBox + rdoPriorityNone: QtWidgets.QToolBox + rdoPriorityLow: QtWidgets.QToolBox + rdoPriorityMed: QtWidgets.QToolBox + rdoPriorityHigh: QtWidgets.QToolBox + spnEscalatesIn: QtWidgets.QSpinBox + spnMuteTimeout: QtWidgets.QSpinBox + lstFlags: QtWidgets.QListWidget + tblTriggeredIDs: QtWidgets.QTableWidget + + priority = AlarmPriority.ALARM_HIGH + flags = 0 + + eColTime = 0 + eColID = 1 + eColMute = 2 + eColEscalate = 3 + eColFlags = 4 + eColMessage = 5 + eColCount = 6 + # column: (width, text) + fixedLabels = { + eColTime: (70, 'Time'), + eColID: (45, 'Top ID'), + eColMute: (100, 'Mute'), + eColEscalate: (45, 'Escl'), + eColFlags: (150, 'Flags'), + eColMessage: (100, 'Message'), + } + + colors = { + AlarmPriority.ALARM_NONE: Qt.green, + AlarmPriority.ALARM_LOW: Qt.yellow, + AlarmPriority.ALARM_MED: Qt.yellow, + AlarmPriority.ALARM_HIGH: Qt.red + } + styles = { + AlarmPriority.ALARM_NONE: 'rgb(78, 154, 6)', + AlarmPriority.ALARM_LOW: 'rgb(237, 212, 0)', + AlarmPriority.ALARM_MED: 'rgb(237, 212, 0)', + AlarmPriority.ALARM_HIGH: 'rgb(239, 41, 41)' + } + + def __init__(self): + super().__init__(os.path.dirname(__file__)) + + def _init_loader(self): + """ + finds and creates widgets + :return: none + """ + self.btnSend = self.find_button('btnSend') + self.btnMute = self.find_button('btnMute') + self.spnTopID = self.find_spinbox('spnTopID') + self.rdoPriorityNone = self.find_tool_button('rdoPriorityNone') + self.rdoPriorityLow = self.find_tool_button('rdoPriorityLow') + self.rdoPriorityMed = self.find_tool_button('rdoPriorityMed') + self.rdoPriorityHigh = self.find_tool_button('rdoPriorityHigh') + self.spnEscalatesIn = self.find_spinbox('spnEscalatesIn') + self.spnMuteTimeout = self.find_spinbox('spnMuteTimeout') + self.lstFlags = self.find_list_widget('lstFlags') + self.tblStatusIDs = self.find_table_widget('tblStatusIDs') + + self.btnTrigger = self.find_button('btnTrigger') + self.btnClear = self.find_button('btnClear') + self.btnCondition = self.find_button('btnCondition') + self.spnAlarmID = self.find_spinbox('spnAlarmID') + self.tblTriggeredIDs = self.find_table_widget('tblTriggeredIDs') + + def _init_widgets(self): + """ + initializes the widgets' properties + :return: none + """ + self.__populate_status_ids_columns() + self.rdoPriorityNone.setStyleSheet('background-color: {};'.format(self.styles[AlarmPriority.ALARM_NONE])) + self.rdoPriorityLow.setStyleSheet('background-color: {};'.format(self.styles[AlarmPriority.ALARM_LOW])) + self.rdoPriorityMed.setStyleSheet('background-color: {};'.format(self.styles[AlarmPriority.ALARM_MED])) + self.rdoPriorityHigh.setStyleSheet('background-color: {};'.format(self.styles[AlarmPriority.ALARM_HIGH])) + + self.tblTriggeredIDs.setColumnWidth(0, 75) + self.tblTriggeredIDs.setColumnWidth(1, 45) + + def _init_connections(self): + """ + initializes the widgets connections + :return: + """ + self.btnTrigger.clicked.connect(self.do_trigger) + self.btnClear.clicked.connect(self.do_clear) + self.btnCondition.clicked.connect(self.do_clear_condition) + self.tblTriggeredIDs.itemClicked.connect(self.on_trigger_ids_item_clicked) + + self.btnSend.clicked.connect(self.do_send) + self.btnMute.clicked.connect(self.do_mute) # item clicked might be enough + self.tblStatusIDs.itemClicked.connect(self.on_status_ids_item_clicked) + self.rdoPriorityNone.toggled.connect(self.do_set_priority_none) + self.rdoPriorityLow.toggled.connect(self.do_set_priority_low) + self.rdoPriorityMed.toggled.connect(self.do_set_priority_med) + self.rdoPriorityHigh.toggled.connect(self.do_set_priority_high) + + def set_flags(self): + """ + the slot for flags + :return: none + """ + highest = False + lst = self.lstFlags + for i in range(lst.count()): + if highest: + bit = pow(2, 15 - i) + else: + bit = pow(2, i) + + if lst.item(i).checkState() == Qt.Checked: + self.flags |= bit + else: + self.flags &= ~bit + + @Slot() + def do_set_priority_none(self): + """ + the slot for priority buttons + :return: none + """ + self.priority = AlarmPriority.ALARM_NONE + + @Slot() + def do_set_priority_low(self): + """ + the slot for priority buttons + :return: none + """ + self.priority = AlarmPriority.ALARM_LOW + + @Slot() + def do_set_priority_med(self): + """ + the slot for priority buttons + :return: none + """ + self.priority = AlarmPriority.ALARM_MED + + @Slot() + def do_set_priority_high(self): + """ + the slot for priority buttons + :return: none + """ + self.priority = AlarmPriority.ALARM_HIGH + + @Slot() + def do_send(self): + """ + the slot for send button + :return: none + """ + alarm_id = self.spnTopID.value() + escalate = self.spnEscalatesIn.value() + mute_out = self.spnMuteTimeout.value() + if alarm_id >= 0: + self.set_flags() + self.hd_simulator.alarms_simulator.cmd_activate_alarm_id(self.priority, + alarm_id, + escalate, + mute_out, + self.flags) + self.__append_status_ids_row(alarm_id) + + @Slot() + def do_trigger(self): + """ + the slot for trigger button + :return: none + """ + alarm_id = self.spnAlarmID.value() + if alarm_id: + self.hd_simulator.alarms_simulator.cmd_set_alarm_triggered(alarm_id) + self.__append_triggered_row(alarm_id) + + @Slot() + def do_clear(self): + """ + the slot for clear button + :return: none + """ + [alarm_id, row] = self.alarm_id() + self.hd_simulator.alarms_simulator.cmd_set_alarm_cleared(alarm_id) + self.tblTriggeredIDs.removeRow(row) + + @Slot() + def do_clear_condition(self): + """ + the slot for condition button + :return: none + """ + [alarm_id, row] = self.alarm_id() + self.hd_simulator.alarms_simulator.cmd_set_alarm_cleared_condition(alarm_id) + self.tblTriggeredIDs.item(row, self.eColID).setBackground(self.colors[AlarmPriority.ALARM_NONE]) + self.tblTriggeredIDs.item(row, self.eColID).setSelected(False) + + @Slot() + def do_mute(self, value): + """ + the slot for mute button + :return: none + """ + print(" --- ", QObject.sender(self).objectName()) + + @Slot() + def on_status_ids_item_clicked(self, item: QtWidgets.QTableWidgetItem): + """ + slot to handle on item clicked + :param item: the clicked item + :return: None + """ + selected = item.isSelected() + self.btnMute.setEnabled(selected) + + @Slot() + def on_trigger_ids_item_clicked(self, item: QtWidgets.QTableWidgetItem): + """ + slot to handle on item clicked + :param item: the clicked item + :return: None + """ + selected = item.isSelected() + self.btnClear.setEnabled(selected) + self.btnCondition.setEnabled(selected) + + def __populate_status_ids_columns(self): + """ + adds alarm flags as columns in the Status alarms table + :return: None + """ + items = sorted(self.fixedLabels.items()) + self.tblStatusIDs.setColumnCount(self.eColCount) + self.tblStatusIDs.setHorizontalHeaderLabels([v[1] for k, v in items]) + for col, item in items: + self.tblStatusIDs.setColumnWidth(col, item[0]) + + def __append_status_ids_row(self, alarm_id): + """ + appends the Status alarm id into the Status list + :return: None + """ + inset_at_top = True + + now = datetime.now().strftime("%H:%M:%S") + + items = self.tblStatusIDs.findItems(str(alarm_id), Qt.MatchExactly) + if len(items): + item: QtWidgets.QTableWidgetItem = items[0] + row = item.row() + else: + row = 0 if inset_at_top else self.tblStatusIDs.rowCount() + self.tblStatusIDs.insertRow(row) + + model = self.tblStatusIDs.model() + model.setData(model.index(row, self.eColTime), now) + model.setData(model.index(row, self.eColID), alarm_id) + model.setData(model.index(row, self.eColMute), self.spnMuteTimeout.value()) + model.setData(model.index(row, self.eColEscalate), self.spnEscalatesIn.value()) + self.tblStatusIDs.item(row, self.eColMute).setCheckState(Qt.Unchecked) + model.setData(model.index(row, self.eColMessage), "N/A") + model.setData(model.index(row, self.eColFlags), '{:016b}'.format(self.flags, 'b')) + self.tblStatusIDs.item(row, self.eColID).setBackground(self.colors[self.priority]) + + def __append_triggered_row(self, alarm_id): + """ + appends the triggered alarm id into the triggered list + :return: None + """ + inset_at_top = True + + now = datetime.now().strftime("%H:%M:%S") + + items = self.tblTriggeredIDs.findItems(str(alarm_id), Qt.MatchExactly) + if len(items): + item: QtWidgets.QTableWidgetItem = items[0] + row = item.row() + else: + row = 0 if inset_at_top else self.tblTriggeredIDs.rowCount() + self.tblTriggeredIDs.insertRow(row) + + model = self.tblTriggeredIDs.model() + model.setData(model.index(row, self.eColTime), now) + model.setData(model.index(row, self.eColID), alarm_id) + self.tblTriggeredIDs.item(row, self.eColID).setBackground(self.colors[AlarmPriority.ALARM_HIGH]) + + def alarm_id(self): + """ + gets the alarm id from the list of the triggered id list + :return: + """ + row = 0 + alarm_id = 0 + items = self.tblTriggeredIDs.selectedItems() + if len(items): + item: QtWidgets.QTableWidgetItem = items[0] + row = item.row() + model = self.tblTriggeredIDs.model() + alarm_id = model.data(model.index(row, self.eColID)) + return [alarm_id, row] Index: simulator/plugins/createtreatment/loader.py =================================================================== diff -u --- simulator/plugins/createtreatment/loader.py (revision 0) +++ simulator/plugins/createtreatment/loader.py (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -0,0 +1,77 @@ +""" +The Heparin ui loader class +""" +import os +from simulator.dynamicloader import DynamicLoader +from PySide2 import QtWidgets +from PySide2.QtCore import Slot + + +class Loader(DynamicLoader): + """ + The Saline Bolus ui loader class + """ + + btnAccept: QtWidgets.QPushButton + btnReject: QtWidgets.QPushButton + lblAction: QtWidgets.QLabel + spnRejectReason: QtWidgets.QSpinBox + + def __init__(self): + super().__init__(os.path.dirname(__file__)) + + def _init_loader(self): + """ + finds and creates widgets + :return: none + """ + # saline adjustment + self.btnAccept = self.find_button('btnAccept') + self.btnReject = self.find_button('btnReject') + self.lblAction = self.find_label('lblAction') + self.spnRejectReason = self.find_spinbox('spnRejectReason') + + def _init_widgets(self): + """ + initializes the widgets' properties + :return: none + """ + pass + + def _init_connections(self): + """ + initializes the widgets connections + :return: + """ + self.btnAccept.clicked.connect(self.do_accept) + self.btnReject.clicked.connect(self.do_reject) + + @Slot() + def do_accept(self): + """ + the slot for accept button + :return: none + """ + self.hd_simulator.cmd_send_start_treatment_response(1, 0) + self.lblAction.setText('Accepted ') + + @Slot() + def do_reject(self): + """ + the slot for accept saline bolus button + :return: none + """ + reason = self.spnRejectReason.value() + self.hd_simulator.cmd_set_heparin_pause_resume_response(False, reason, self.requested_state) + self.lblAction.setText('Rejected ' + "{}".format(reason)) + + @Slot() + def do_data(self, value): + """ + the slot which is called to send the data + by calling the denaliMessage API setTreatmentHeparinData + :return: none + """ + volume = value * 0.1 + self.hd_simulator.cmd_set_treatment_heparin_data(volume) + self.lblCumulative.setNum(volume) Index: simulator/plugins/heparin/loader.py =================================================================== diff -u -rf921975179b1c1ad61d841b9db5976c00432fdcc -r310f51a5ed4921f184572f90d07b350ec41c0bae --- simulator/plugins/heparin/loader.py (.../loader.py) (revision f921975179b1c1ad61d841b9db5976c00432fdcc) +++ simulator/plugins/heparin/loader.py (.../loader.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -5,8 +5,7 @@ from simulator.dynamicloader import DynamicLoader from PySide2 import QtWidgets from PySide2.QtCore import Slot -from dialin.squish import denaliMessages -from dialin.squish.denaliMessages import txStates +from dialin.ui.hd_simulator import TXStates class Loader(DynamicLoader): @@ -21,11 +20,11 @@ spnRejectReason: QtWidgets.QSpinBox sldCumulative: QtWidgets.QSlider - requested_state: txStates + requested_state: TXStates def __init__(self): super().__init__(os.path.dirname(__file__)) - self.requested_state = txStates.HEPARIN_STATE_PAUSED + self.requested_state = TXStates.HEPARIN_STATE_PAUSED def _init_loader(self): """ @@ -66,12 +65,12 @@ :return: none """ # toggle the requested state - if self.requested_state == txStates.HEPARIN_STATE_DISPENSING: - self.requested_state = txStates.HEPARIN_STATE_PAUSED + if self.requested_state == TXStates.HEPARIN_STATE_DISPENSING: + self.requested_state = TXStates.HEPARIN_STATE_PAUSED else: - self.requested_state = txStates.HEPARIN_STATE_DISPENSING + self.requested_state = TXStates.HEPARIN_STATE_DISPENSING - denaliMessages.setHeparinResponse(True, 0, self.requested_state) + self.hd_simulator.cmd_set_heparin_pause_resume_response(True, 0, self.requested_state) self.lblAction.setText('Accepted ') @Slot() @@ -81,7 +80,7 @@ :return: none """ reason = self.spnRejectReason.value() - denaliMessages.setHeparinResponse(False, reason, self.requested_state) + self.hd_simulator.cmd_set_heparin_pause_resume_response(False, reason, self.requested_state) self.lblAction.setText('Rejected ' + "{}".format(reason)) @Slot() @@ -92,5 +91,5 @@ :return: none """ volume = value * 0.1 - denaliMessages.setTreatmentHeparinData(volume) + self.hd_simulator.cmd_set_treatment_heparin_data(volume) self.lblCumulative.setNum(volume) Index: simulator/plugins/inlinebloodpressures/loader.py =================================================================== diff -u -rf921975179b1c1ad61d841b9db5976c00432fdcc -r310f51a5ed4921f184572f90d07b350ec41c0bae --- simulator/plugins/inlinebloodpressures/loader.py (.../loader.py) (revision f921975179b1c1ad61d841b9db5976c00432fdcc) +++ simulator/plugins/inlinebloodpressures/loader.py (.../loader.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -5,9 +5,8 @@ from simulator.dynamicloader import DynamicLoader from PySide2 import QtWidgets from PySide2.QtCore import Slot -from dialin.squish import denaliMessages -from dialin.squish.denaliMessages import txStates, EResponse from dialin.common import Ranges +from dialin.ui import TXStates, EResponse class Loader(DynamicLoader): @@ -36,7 +35,7 @@ def __init__(self): super().__init__(os.path.dirname(__file__)) - self.saline_requested_state = txStates.SALINE_BOLUS_STATE_IDLE + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IDLE def _init_loader(self): """ @@ -122,7 +121,7 @@ sends the pressures values message with given value on the screen :return: none """ - denaliMessages.setPressureOcclusionData( + self.hd_simulator.cmd_set_pressure_occlusion_data( self.sldArterialValue.value(), self.sldVenousValue.value(), 0, 0, 0 @@ -135,7 +134,7 @@ :return: none """ # vAccepted, vReason, vArterialLow, vArterialHigh, vVenousLow, vVenousHigh - denaliMessages.sendTreatmentAdjustPressuresLimitsResponse( + self.hd_simulator.cmd_send_treatment_adjust_pressures_limit_response( EResponse.Accepted, 0, self.spnArterialLimitLow.value(), self.spnArterialLimitHigh.value(), @@ -151,7 +150,7 @@ :return: none """ reason = self.spnAVPressuresRejectReason.value() - denaliMessages.sendTreatmentAdjustPressuresLimitsResponse( + self.hd_simulator.cmd_send_treatment_adjust_pressures_limit_response( EResponse.Rejected, reason, self.spnArterialLimitLow.value(), self.spnArterialLimitHigh.value(), Index: simulator/plugins/salinebolus/loader.py =================================================================== diff -u -rf921975179b1c1ad61d841b9db5976c00432fdcc -r310f51a5ed4921f184572f90d07b350ec41c0bae --- simulator/plugins/salinebolus/loader.py (.../loader.py) (revision f921975179b1c1ad61d841b9db5976c00432fdcc) +++ simulator/plugins/salinebolus/loader.py (.../loader.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -5,10 +5,8 @@ from simulator.dynamicloader import DynamicLoader from PySide2 import QtWidgets from PySide2.QtCore import Slot -from dialin.squish import denaliMessages -from dialin.squish.denaliMessages import txStates +from dialin.ui import TXStates - class Loader(DynamicLoader): """ The Saline Bolus ui loader class @@ -23,11 +21,11 @@ sldSalineCumulative: QtWidgets.QSlider sldSalineVolume: QtWidgets.QSlider - saline_requested_state: txStates + saline_requested_state: TXStates def __init__(self): super().__init__(os.path.dirname(__file__)) - self.saline_requested_state = txStates.SALINE_BOLUS_STATE_IDLE + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IDLE def _init_loader(self): """ @@ -72,13 +70,13 @@ :return: none """ # toggle the saline requested state - if self.saline_requested_state == txStates.SALINE_BOLUS_STATE_IN_PROGRESS: - self.saline_requested_state = txStates.SALINE_BOLUS_STATE_IDLE + if self.saline_requested_state == TXStates.SALINE_BOLUS_STATE_IN_PROGRESS: + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IDLE else: - self.saline_requested_state = txStates.SALINE_BOLUS_STATE_IN_PROGRESS + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IN_PROGRESS target = self.cmbSalineAcceptTarget.currentText() - denaliMessages.setSalineBolusResponse(True, 0, target, self.saline_requested_state) + self.hd_simulator.cmd_set_saline_bolus_response(True, 0, target, self.saline_requested_state) self.lblSalineAction.setText('Accepted ' + target) @Slot() @@ -88,7 +86,7 @@ :return: none """ reason = self.spnSalineRejectReason.value() - denaliMessages.setSalineBolusResponse(False, reason, 0, self.saline_requested_state) + self.hd_simulator.cmd_set_saline_bolus_response(False, reason, 0, self.saline_requested_state) self.lblSalineAction.setText('Rejected ' + "{}".format(reason)) @@ -99,6 +97,6 @@ by calling the denaliMessage API setTreatmentSalineBolusData :return: none """ - denaliMessages.setTreatmentSalineBolusData(self.sldSalineTarget.value(), + self.hd_simulator.cmd_set_treatment_saline_bolus_data(self.sldSalineTarget.value(), self.sldSalineCumulative.value(), self.sldSalineVolume.value()) Index: simulator/plugins/treatmentranges/loader.py =================================================================== diff -u -rf921975179b1c1ad61d841b9db5976c00432fdcc -r310f51a5ed4921f184572f90d07b350ec41c0bae --- simulator/plugins/treatmentranges/loader.py (.../loader.py) (revision f921975179b1c1ad61d841b9db5976c00432fdcc) +++ simulator/plugins/treatmentranges/loader.py (.../loader.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -6,7 +6,6 @@ from PySide2 import QtWidgets from PySide2.QtCore import QTimer from PySide2.QtCore import Slot -from dialin.squish import denaliMessages class Loader(DynamicLoader): @@ -63,7 +62,7 @@ sends the duration message :return: none """ - denaliMessages.setTreatmentTime(self.spnDurationMax.value() * 60, value) + self.hd_simulator.cmd_set_treatment_time(self.spnDurationMax.value() * 60, value) @Slot() def do_ranges_data(self): @@ -77,7 +76,7 @@ self.sldDurationValue.setMinimum(duration_min * 60) self.sldDurationValue.setMaximum(duration_max * 60) - denaliMessages.setTreatmentParamRanges( + self.hd_simulator.cmd_set_treatment_parameter_ranges( duration_min, duration_max, self.spnUFVolumeMin.value(), Index: simulator/plugins/treatmentstates/loader.py =================================================================== diff -u -rf921975179b1c1ad61d841b9db5976c00432fdcc -r310f51a5ed4921f184572f90d07b350ec41c0bae --- simulator/plugins/treatmentstates/loader.py (.../loader.py) (revision f921975179b1c1ad61d841b9db5976c00432fdcc) +++ simulator/plugins/treatmentstates/loader.py (.../loader.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -5,8 +5,7 @@ from simulator.dynamicloader import DynamicLoader from PySide2 import QtWidgets from PySide2.QtCore import Slot -from dialin.squish import denaliMessages -from dialin.squish.denaliMessages import txStates +from dialin.ui import TXStates class Loader(DynamicLoader): @@ -48,19 +47,19 @@ initializes the widgets' properties :return: none """ - self.tblSubMode.setCurrentCell(txStates.TREATMENT_DIALYSIS_STATE, 0) - self.tblUFStates.setCurrentCell(txStates.UF_OFF_STATE, 0) - self.tblSalineStates.setCurrentCell(txStates.SALINE_BOLUS_STATE_IDLE, 0) - self.tblHeparinStates.setCurrentCell(txStates.HEPARIN_STATE_OFF, 0) + self.tblSubMode.setCurrentCell(TXStates.TREATMENT_DIALYSIS_STATE, 0) + self.tblUFStates.setCurrentCell(TXStates.UF_OFF_STATE, 0) + self.tblSalineStates.setCurrentCell(TXStates.SALINE_BOLUS_STATE_IDLE, 0) + self.tblHeparinStates.setCurrentCell(TXStates.HEPARIN_STATE_OFF, 0) @Slot() def do_treatment_states(self): """ the slot for saline bolus state change :return: none """ - sub_mode = self.tblSubMode.verticalHeaderItem(self.tblSubMode.currentRow()).text() - uf_state = self.tblUFStates.verticalHeaderItem(self.tblUFStates.currentRow()).text() - saline = self.tblSalineStates.verticalHeaderItem(self.tblSalineStates.currentRow()).text() - heparin = self.tblHeparinStates.verticalHeaderItem(self.tblHeparinStates.currentRow()).text() - denaliMessages.setTreatmentStatesData(sub_mode, uf_state, saline, heparin) + sub_mode = int(self.tblSubMode.verticalHeaderItem(self.tblSubMode.currentRow()).text()) + uf_state = int(self.tblUFStates.verticalHeaderItem(self.tblUFStates.currentRow()).text()) + saline = int(self.tblSalineStates.verticalHeaderItem(self.tblSalineStates.currentRow()).text()) + heparin = int(self.tblHeparinStates.verticalHeaderItem(self.tblHeparinStates.currentRow()).text()) + self.hd_simulator.cmd_set_treatment_states_data(sub_mode, uf_state, saline, heparin) Index: simulator/plugins/ultrafiltration/loader.py =================================================================== diff -u -r9206e36aeff354823f2c37103d79f548221cd64c -r310f51a5ed4921f184572f90d07b350ec41c0bae --- simulator/plugins/ultrafiltration/loader.py (.../loader.py) (revision 9206e36aeff354823f2c37103d79f548221cd64c) +++ simulator/plugins/ultrafiltration/loader.py (.../loader.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -5,8 +5,7 @@ from simulator.dynamicloader import DynamicLoader from PySide2 import QtWidgets from PySide2.QtCore import Slot -from dialin.squish import denaliMessages -from dialin.squish.denaliMessages import txStates, EResponse +from dialin.ui import HDSimulator, TXStates, EResponse class Loader(DynamicLoader): @@ -79,8 +78,8 @@ the slot for accept ultrafiltration pause button :return: none """ - denaliMessages.setTreatmentAdjustUltrafiltrationStateResponse( - EResponse.Accepted, 0, txStates.UF_PAUSED_STATE) + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Accepted, 0, TXStates.UF_PAUSED_STATE) self.lblUfPauseAction.setText('Accepted ') @Slot() @@ -90,8 +89,8 @@ :return: none """ reason = self.spnUfPauseRejectReason.value() - denaliMessages.setTreatmentAdjustUltrafiltrationStateResponse( - EResponse.Rejected, reason, txStates.UF_RUNNING_STATE) + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Rejected, reason, TXStates.UF_RUNNING_STATE) self.lblUfPauseAction.setText('Rejected ' + "{}".format(reason)) @Slot() @@ -100,8 +99,8 @@ the slot for accept ultrafiltration resume accept :return: none """ - denaliMessages.setTreatmentAdjustUltrafiltrationStateResponse( - EResponse.Accepted, 0, txStates.UF_RUNNING_STATE) + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Accepted, 0, TXStates.UF_RUNNING_STATE) self.lblUfResumeAction.setText('Accepted ') @Slot() @@ -111,8 +110,8 @@ :return: none """ reason = self.spnUfResumeRejectReason.value() - denaliMessages.setTreatmentAdjustUltrafiltrationStateResponse( - EResponse.Rejected, reason, txStates.UF_PAUSED_STATE) + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Rejected, reason, TXStates.UF_PAUSED_STATE) self.lblUfResumeAction.setText('Rejected ' + "{}".format(reason)) @Slot() @@ -121,7 +120,7 @@ the slot for accept ultrafiltration next button :return: none """ - denaliMessages.setTreatmentAdjustUltrafiltrationEditResponse( + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_edit_response( EResponse.Accepted, 0, 2500, 60, 0, 10, 0, 10) self.lblUfEditAction.setText('Accepted ') @@ -132,7 +131,7 @@ :return: none """ reason = self.spnUfEditRejectReason.value() - denaliMessages.setTreatmentAdjustUltrafiltrationEditResponse( + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_edit_response( EResponse.Rejected, reason, 2500, 60, 0, 10, 0, 10) self.lblUfEditAction.setText('Rejected ' + "{}".format(reason)) @@ -142,5 +141,5 @@ sends the ultrafiltration delivered volume message :return: none """ - denaliMessages.setTreatmentUltrafiltration(self.sldUfVolume.value(), 0, 0, 0, 0, 0, 0) + self.hd_simulator.cmd_set_treatment_ultrafiltration_outlet_flow_data(self.sldUfVolume.value(), 0, 0, 0, 0, 0, 0) Index: simulator/simulator/dynamicloader.py =================================================================== diff -u --- simulator/simulator/dynamicloader.py (revision 0) +++ simulator/simulator/dynamicloader.py (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -0,0 +1,180 @@ +""" + find and loads the ui objects +""" +import os +from PySide2.QtUiTools import QUiLoader +from PySide2.QtCore import QFile, QObject +from PySide2 import QtWidgets +from dialin import HDSimulator + + +class DynamicLoader(QObject): + """ + the parent class of all the run time loadable widgets + """ + + canMaximize = False + isVisible = False + menu_name = 'Dynamic Loader' + + loader: QUiLoader + window: QtWidgets.QWidget + + hd_simulator: HDSimulator + + def __init__(self, location: str): + super().__init__(None) + self.location = location + self.hd_simulator = HDSimulator() + self.loader = QUiLoader() + self.__load_ui() + self._init_loader() + self._init_widgets() + self._init_connections() + + def _init_loader(self): + """ + Virtual method to be implemented in the child class and should be called in order + Main purpose is to find/create the widgets objects in this method + :return: None + """ + raise NotImplementedError() + + def _init_widgets(self): + """ + Virtual method to be implemented in the child class and should be called in order + Main purpose is to setup/initialize widgets properties in this method + :return: None + """ + raise NotImplementedError() + + def _init_connections(self): + """ + Virtual method to be implemented in the child class and should be called in order + Main purpose is to initial the widgets signal/slots connections in this method + :return: None + """ + raise NotImplementedError() + + def __load_ui(self): + """ + loads the ui file of the GUI at run time + :return: none + """ + ui_file = QFile(self.location + "/interface.ui") + ui_file.open(QFile.ReadOnly) + self.window = self.loader.load(ui_file) + # assert if the ui file can't be loaded + error = self.loader.errorString() + assert len(error) == 0, error + ui_file.close() + + def show(self): + """ + shows the main container window + :return: none + """ + self.window.show() + + def find_widget(self, child_type, child_name: str) -> QtWidgets.QWidget: + """ + finds a child in the loaded ui and returns the reference to it if found + otherwise quits the application + :param child_type: (var) type of the child + :param child_name: (str) name of the child + :return: (QtWidgets.QWidget) reference to the child + """ + child: QtWidgets.QWidget = self.window.findChild(child_type, child_name) + assert child is not None, "child name '{}' with type '{}' can't be found.".format(child_name, child_type) + return child + + def find_action(self, name: str) -> QtWidgets.QAction: + """ + convenient method of find_widget for QAction + :param name: (str) name of the QLabel Object + :return: (QAction) reference to the QAction + """ + child = self.find_widget(QtWidgets.QAction, name) + return child + + def find_label(self, name: str) -> QtWidgets.QLabel: + """ + convenient method of find_widget for QLabel + :param name: (str) name of the QLabel Object + :return: (QLabel) reference to the QLabel + """ + child = self.find_widget(QtWidgets.QLabel, name) + return child + + def find_button(self, name: str) -> QtWidgets.QPushButton: + """ + convenient method of find_widget for QPushButton + :param name: (str) name of the QPushButton Object + :return: (QPushButton) reference to the QPushButton + """ + child = self.find_widget(QtWidgets.QPushButton, name) + return child + + def find_combobox(self, name: str) -> QtWidgets.QComboBox: + """ + convenient method of find_widget for QComboBox + :param name: (str) name of the QComboBox Object + :return: (QComboBox) reference to the QComboBox + """ + child = self.find_widget(QtWidgets.QComboBox, name) + return child + + def find_checkbox(self, name: str) -> QtWidgets.QCheckBox: + """ + convenient method of find_widget for QCheckBox + :param name: (str) name of the QCheckBox Object + :return: (QCheckBox) reference to the QComboBox + """ + child = self.find_widget(QtWidgets.QCheckBox, name) + return child + + def find_spinbox(self, name: str) -> QtWidgets.QSpinBox: + """ + convenient method of find_widget for QSpinBox + :param name: (str) name of the QSpinBox Object + :return: (QSpinBox) reference to the QSpinBox + """ + child = self.find_widget(QtWidgets.QSpinBox, name) + return child + + def find_slider(self, name: str) -> QtWidgets.QSlider: + """ + convenient method of find_widget for QSlider + :param name: (str) name of the QSlider Object + :return: (QSlider) reference to the QSlider + """ + child = self.find_widget(QtWidgets.QSlider, name) + return child + + def find_table_widget(self, name: str) -> QtWidgets.QTableWidget: + """ + convenient method of find_widget for QTableWidget + :param name: (str) name of the QTableWidget Object + :return: (QTableWidget) reference to the QTableWidget + """ + child: QtWidgets.QTableWidget = self.find_widget(QtWidgets.QTableWidget, name) + return child + + def find_list_widget(self, name: str) -> QtWidgets.QListWidget: + """ + convenient method of find_widget for QListWidget + :param name: (str) name of the QListWidget Object + :return: (QListWidget) reference to the QListWidget + """ + child: QtWidgets.QListWidget = self.find_widget(QtWidgets.QListWidget, name) + return child + + def find_tool_button(self, name: str) -> QtWidgets.QToolButton: + """ + convenient method of find_widget for QToolButton + :param name: (str) name of the QToolButton Object + :return: (QToolButton) reference to the QToolButton + """ + child: QtWidgets.QToolButton = self.find_widget(QtWidgets.QToolButton, name) + return child + Index: tools/check_setup.sh =================================================================== diff -u --- tools/check_setup.sh (revision 0) +++ tools/check_setup.sh (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -0,0 +1,27 @@ +#!/bin/bash + +cd ../ + +dir="venv/lib/python3.6/site-packages/dialin" +venv_dir="$(pwd)/venv" +paths_ini=/opt/squishqt/etc/paths.ini +python_home="Scripting/PythonHome = \"$venv_dir\"" +library_path=":$venv_dir/bin" + +if [[ -L "$dir" && -d "$dir" ]]; then + echo "Using local dialin" +else + echo "Using remote dialin" +fi + +if grep -q "$python_home" $paths_ini; then + echo "Pass: Scripting/PythonHome in $paths_ini points to $venv_dir." +else + echo "Fail: Scripting/PythonHome in $paths_ini does not point to $venv_dir." +fi + +if grep -q "$library_path" $paths_ini; then + echo "Pass: LibraryPath in $paths_ini includes $library_path." +else + echo "Fail: LibraryPath in $paths_ini does not include $library_path." +fi Index: tst_AlarmStatusData/test.py =================================================================== diff -u -r8e2d609349eacfe609a48bc6a332d74d102c212d -r310f51a5ed4921f184572f90d07b350ec41c0bae --- tst_AlarmStatusData/test.py (.../test.py) (revision 8e2d609349eacfe609a48bc6a332d74d102c212d) +++ tst_AlarmStatusData/test.py (.../test.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -14,7 +14,9 @@ import names -from dialin.squish import utils, denaliMessages +from dialin.ui import utils +from dialin import HDSimulator +HDSimulator = HDSimulator() # buttons position/definition in alarm flags @@ -200,7 +202,6 @@ startApplication(names.AUT_NAME + " -q") utils.waitForGUI(1) - # --------------------- Alarm Dialog: test the buttons for buttons in (alarm_buttons_Ok , alarm_buttons_Resume , @@ -210,35 +211,35 @@ alarm_buttons_Resume_End , alarm_buttons_RinseBack_End , alarm_buttons_Resume_RinseBack_End ): - denaliMessages.setAlarmStatus(1, 1, 0, 0, buttons) + HDSimulator.alarms_simulator.cmd_activate_alarm_id(1, 1, 0, 0, buttons) test_buttons ( buttons) ## -------------------- Alarm Dialog/Bar: test silence # --------------------- Alarm Dialog/Bar: not muted for mute_timeout in (0, 40, 40, 60, 75, 75): - denaliMessages.setAlarmStatus(1, 1 ,0, mute_timeout, alarm_flag_unmute) + HDSimulator.alarms_simulator.cmd_activate_alarm_id(1, 1 ,0, mute_timeout, alarm_flag_unmute) test_silence ( mute_timeout, alarm_flag_unmute) # --------------------- Alarm Dialog/Bar: muted mouseClick(waitForObject(names.o_alarm_button_mute)) for mute_timeout in (0, 10, 20, 30, 30, 100): - denaliMessages.setAlarmStatus(1, 2 ,0, mute_timeout, alarm_flag_mute) + HDSimulator.alarms_simulator.cmd_activate_alarm_id(1, 2 ,0, mute_timeout, alarm_flag_mute) test_silence ( mute_timeout, alarm_flag_mute) ## -------------------- Alarm Dialog/Bar: test alarm messages mouseClick(waitForObject(names.o_alarm_button_mute)) for alarm_id in (5, 5 , 6, 7, 8, 9, 10, 10, alarm_id_outofrange, alarm_id_outofrange, alarm_id_noalarm, alarm_id_noalarm): # not all of alarms are required to be tested. - denaliMessages.setAlarmStatus(1, alarm_id, 0, 0, 0) + HDSimulator.alarms_simulator.cmd_activate_alarm_id(1, alarm_id, 0, 0, 0) test_messages ( alarm_id ) ## -------------------- Alarm Dialog/Bar: test alarm priority colors for alarm_priority in alarm_priorities: - denaliMessages.setAlarmStatus(alarm_priority, 1, 0, 0, 0) + HDSimulator.alarms_simulator.cmd_activate_alarm_id(alarm_priority, 1, 0, 0, 0) test_colors (alarm_priority ) Index: tst_ConfirmPrimingBegin/test.py =================================================================== diff -u -rf29743f1a3b34472a3df5eaa4f8861fbc425f9ee -r310f51a5ed4921f184572f90d07b350ec41c0bae --- tst_ConfirmPrimingBegin/test.py (.../test.py) (revision f29743f1a3b34472a3df5eaa4f8861fbc425f9ee) +++ tst_ConfirmPrimingBegin/test.py (.../test.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -1,9 +1,10 @@ # -*- coding: utf-8 -*-" import names -from dialin.squish import utils +from dialin.ui import utils from dialin.ui.hd_simulator import HDSimulator from dialin.common.msg_defs import RequestRejectReasons +from dialin.ui.utils import waitForGUI def skip_create_treatment(hd_simulator: HDSimulator): """ @@ -29,57 +30,51 @@ skip_create_treatment(hd_simulator) - test.compare(waitForObjectExists(names.o_confirm_treatment_flickable).visible, True, "Found confirm treatment flickable") + test.compare(waitForObject(names.o_confirm_treatment_flickable).visible, True, "Found confirm treatment flickable") - utils.waitForGUI(1) # object not ready flick(waitForObject(names.o_confirm_treatment_flickable), 0, 700) mouseClick(waitForObject(names.o_create_treatment_confirm)) # wait for priming simulation to complete - utils.waitForGUI(7) + waitForGUI(7) # advance to start the treatment - test.compare(waitForObject(names.o_priming_flickable).visible, True, "Found priming flickable") - flick(waitForObject(names.o_priming_flickable), 0, 123) test.compare(waitForObject(names.o_priming_continue_button).visible, True, "Found priming continue button") mouseClick(waitForObject(names.o_priming_continue_button)) - utils.waitForGUI(0.5) # object not ready - test.compare(waitForObjectExists(names.o_treatment_begin_back_button).visible, True, "Found treatment begin back button") mouseClick(waitForObject(names.o_treatment_begin_back_button)) - utils.waitForGUI(0.5) # object not ready test.compare(waitForObject(names.o_priming_back_button).visible, True, "Found priming back button") - mouseClick(waitForObject(names.o_priming_back_button)) - utils.waitForGUI(0.5) # object not ready test.compare(waitForObject(names.o_create_treatment_confirm_back_button).visible, True, "Found create treatment confirm back button") - - mouseClick(waitForObject(names.o_create_treatment_confirm_back_button)) - utils.waitForGUI(0.5) + mouseClick(waitForObject(names.o_create_treatment_confirm_back_button)) test.compare(waitForObject(names.o_create_treatment_back_button).visible, True, "Found create treatment back button") - mouseClick(waitForObject(names.o_create_treatment_back_button)) - utils.waitForGUI(0.5) + waitForGUI(0.1) mouseClick(waitForObject(names.o_create_treatment_button)) - utils.waitForGUI(0.5) + waitForGUI(0.1) skip_create_treatment(hd_simulator) - utils.waitForGUI(1) - test.compare(waitForObjectExists(names.o_create_treatment_confirm).visible, True, "Found treatment confirm button") + test.compare(waitForObject(names.o_create_treatment_confirm).visible, True, "Found treatment confirm button") mouseClick(waitForObject(names.o_create_treatment_confirm)) # wait for priming simulation to complete - utils.waitForGUI(7) + waitForGUI(7) test.compare(waitForObject(names.o_priming_continue_button).visible, True, "Found priming continue button") mouseClick(waitForObject(names.o_priming_continue_button)) test_ultrafiltration_slider(hd_simulator) + + # Wait for the BLE alert + mouseClick(waitForObject(names.o_treatment_begin_start_button)) + test.compare(waitForObject(names.o_alert).visible, True, "Found alert") + mouseClick(waitForObject(names.o_alert_confirm)) + test.compare(waitForObject(names.o_treatment_begin_start_button).visible, True, "Found treatment start button") mouseClick(waitForObject(names.o_treatment_begin_start_button)) - utils.waitForGUI(0.1) + waitForGUI(0.2) mouseClick(waitForObject(names.o_treatmentStart_back)) mouseClick(waitForObject(names.o_mainMenu_settings)) mouseClick(waitForObject(names.o_settings_end_treatment)) - utils.waitForGUI(3) + waitForGUI(3) def test_ultrafiltration_slider(hd_simulator: HDSimulator): """ @@ -88,9 +83,9 @@ @param hd_siulator: The HDSimulator object @return: None """ - slider_name = "_ultrafiltration" + slider_name = "_treatmentBeginUltrafiltration" slider_object_name = slider_name + "Slider" - # test.log("Slider Under Test", slider_object_name) + test.log("Slider Under Test", slider_object_name) slider_selected_value_object_name = slider_name + "Value" slider_object = {"container": names.o_treatment_begin_container, "objectName": slider_object_name, @@ -102,15 +97,15 @@ "type": "Text" } - test.compare(waitForObjectExists(selected_value_object).visible, True) + test.compare(waitForObject(selected_value_object).visible, True) mouseClick(waitForObject(slider_object), 0, 0, Qt.LeftButton) - test.compare(waitForObject(selected_value_object).text, "{0} {1}".format(0, "mL")) + test.compare(waitForObject(selected_value_object).text, "0.000") mouseClick(waitForObject(slider_object), waitForObject(slider_object).width, 0, Qt.LeftButton) test.compare(waitForObject(selected_value_object).visible, True) - test.compare(waitForObject(selected_value_object).text, "{0} {1}".format(8, "mL")) + test.compare(waitForObject(selected_value_object).text, "8.000") def main(): utils.tstStart(__file__) Index: tst_CreateTreatment/test.py =================================================================== diff -u -r90d25f34aa147e502583fab7c9e4fd4a980dd4e8 -r310f51a5ed4921f184572f90d07b350ec41c0bae --- tst_CreateTreatment/test.py (.../test.py) (revision 90d25f34aa147e502583fab7c9e4fd4a980dd4e8) +++ tst_CreateTreatment/test.py (.../test.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -1,11 +1,10 @@ # -*- coding: utf-8 -*-" import names - -from dialin.squish import utils +from time import sleep +from dialin.ui import utils from dialin.common.msg_defs import RequestRejectReasons from dialin import HDSimulator -from time import sleep slider_ranges = { "bloodFlowRateMin": 100, @@ -87,8 +86,6 @@ "_dialyzerTypeRect": "GridSelection", "_dialysateTemperature": "SliderCreateTreatment", - "_arterialPressureLimits": "SliderDoubleCreateTreatment", - "_venousPressureLimits": "SliderDoubleCreateTreatment", "_bloodPressureMeasurementInterval": "SliderCreateTreatment", "_rinsebackFlowRate": "SliderCreateTreatment", @@ -102,7 +99,14 @@ "objectName": parameter_name, "type": type_name }).visible, True, "Found " + parameter_name) + + # arterial and venous pressure limits + test.compare(waitForObjectExists(names.o_create_treatment_arterial_column).visible, True, "Found Arterial Pressure Limits Column") + test.compare(waitForObjectExists(names.o_create_treatment_arterial_slider).visible, True, "Found Arterial Pressure Limits Slider") + test.compare(waitForObjectExists(names.o_create_treatment_venous_column).visible, True, "Found Venous Pressure Limits Column") + test.compare(waitForObjectExists(names.o_create_treatment_venous_slider).visible, True, "Found Arterial Pressure Limits Slider") + def test_sliders(): """ Tests that all sliders have the correct min / max values and that the selected value is displayed correctly. @@ -120,10 +124,6 @@ "_heparinStopTime": {"min": slider_ranges["heparinStopTimeMin"], "max": slider_ranges["heparinStopTimeMax"], "units": "min" }, "_salineBolus": {"min": slider_ranges["salineBolusMin"], "max": slider_ranges["salineBolusMax"], "units": "mL" }, "_dialysateTemperature": {"min": slider_ranges["dialysateTempMin"], "max": slider_ranges["dialysateTempMax"], "units": "C" }, - "_arterialPressureLimitsLow": {"min": slider_ranges["arterialPressureLimitLowMin"], "max": slider_ranges["arterialPressureLimitLowMax"], "units": "mmHg" }, - "_arterialPressureLimitsHigh": {"min": slider_ranges["arterialPressureLimitHighMin"], "max": slider_ranges["arterialPressureLimitHighMax"], "units": "mmHg" }, - "_venousPressureLimitsLow": {"min": slider_ranges["venousPressureLimitLowMin"], "max": slider_ranges["venousPressureLimitLowMax"], "units": "mmHg" }, - "_venousPressureLimitsHigh": {"min": slider_ranges["venousPressureLimitHighMin"], "max": slider_ranges["venousPressureLimitHighMax"], "units": "mmHg" }, "_bloodPressureMeasurementInterval": {"min": slider_ranges["bloodPressureMeasureIntervalMin"], "max": slider_ranges["bloodPressureMeasureIntervalMax"], "units": "min" }, "_rinsebackFlowRate": {"min": slider_ranges["rinsebackFlowRateMin"], "max": slider_ranges["rinsebackFlowRateMax"], "units": "mL/min" }, } @@ -135,7 +135,7 @@ if slider_name == "_dialysateTemperature": flick(waitForObject(names.o_create_treatment_flickable), 0, 700) sleep(1) - if slider_name == "_venousPressureLimitsHigh": + if slider_name == "_bloodPressureMeasurementInterval": flick(waitForObject(names.o_create_treatment_flickable), 0, 300) sleep(2) @@ -176,7 +176,27 @@ test.compare(waitForObject(selected_value_object).visible, True) test.compare(waitForObject(selected_value_object).text, "{0} {1}".format(slider_info["max"], slider_info["units"])) +def test_pressure_limits(): + """ + Tests the arterial and venous pressure limits sliders + """ + objects = [names.o_create_treatment_arterial_slider, names.o_create_treatment_venous_slider] + for obj in objects: + mouseClick(waitForObject(obj), waitForObject(obj).width / 3, 5, Qt.LeftButton) + mouseDrag(waitForObject(obj), + waitForObject(obj).width / 2, + 0, + -waitForObject(obj).width / 2, + 0, + Qt.NoModifier, + Qt.LeftButton) + mouseClick(waitForObject(obj), waitForObject(obj).width *(2/3), 5, Qt.LeftButton) + mouseClick(waitForObject(obj), waitForObject(obj).width - 2, 0, Qt.LeftButton) + + + + def check_button_group(buttons, slider_ranges_key): for idx, btn in enumerate(buttons): @@ -273,6 +293,7 @@ test_continue_failure(hd_simulator) test_parameters_exist() test_sliders() + test_pressure_limits() test_rects() test_continue_success(hd_simulator) utils.tstDone() Index: tst_HDOperationModeData/test.py =================================================================== diff -u -rab2ebd8c7b5c8df145c2b8cc06a397258ecf2f13 -r310f51a5ed4921f184572f90d07b350ec41c0bae --- tst_HDOperationModeData/test.py (.../test.py) (revision ab2ebd8c7b5c8df145c2b8cc06a397258ecf2f13) +++ tst_HDOperationModeData/test.py (.../test.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -13,7 +13,9 @@ # import names -from dialin.squish import utils, denaliMessages +from dialin.ui import utils +from dialin import HDSimulator +HDSimulator = HDSimulator() opModes = [ @@ -34,9 +36,9 @@ def test_values(vOpMode): if (vOpMode < len(opModes)): - test.compare(str(waitForObjectExists(names.o_managerHome_HDOperationModeData_OpMode).text), opModes[vOpMode]) + test.compare(str(waitForObjectExists(utils.dict_update(names.o_managerHome_HDOperationModeData_OpMode, "text", opModes[vOpMode])).text), opModes[vOpMode]) else: - test.compare(str(waitForObjectExists(names.o_managerHome_HDOperationModeData_OpMode).text), "UNDEFINED [{}]".format(vOpMode)) + test.compare(str(waitForObjectExists(utils.dict_update(names.o_managerHome_HDOperationModeData_OpMode, "text", "UNDEFINED [{}]".format(vOpMode))).text), "UNDEFINED [{}]".format(vOpMode)) def main(): @@ -50,21 +52,21 @@ step = 1 for i in range ( 0, len(opModes), step): - denaliMessages.setHDOperationModeData(i + step * 0) + HDSimulator.cmd_set_hd_operation_mode_data(i + step * 0) test_values (i + step * 0) - denaliMessages.setHDOperationModeData(1) + HDSimulator.cmd_set_hd_operation_mode_data(1) test_values (1) # Coverage - denaliMessages.setHDOperationModeData(1) + HDSimulator.cmd_set_hd_operation_mode_data(1) test_values (1) - denaliMessages.setHDOperationModeData(0) + HDSimulator.cmd_set_hd_operation_mode_data(0) test_values (0) outOfRangeCheck = len(opModes) + 1 - denaliMessages.setHDOperationModeData(outOfRangeCheck) + HDSimulator.cmd_set_hd_operation_mode_data(outOfRangeCheck) test_values (outOfRangeCheck) utils.tstDone() Index: tst_Treatment_Adjustment_Heparin/test.py =================================================================== diff -u -rab2ebd8c7b5c8df145c2b8cc06a397258ecf2f13 -r310f51a5ed4921f184572f90d07b350ec41c0bae --- tst_Treatment_Adjustment_Heparin/test.py (.../test.py) (revision ab2ebd8c7b5c8df145c2b8cc06a397258ecf2f13) +++ tst_Treatment_Adjustment_Heparin/test.py (.../test.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -14,9 +14,9 @@ import names -from dialin.squish import utils, denaliMessages -from dialin.squish.denaliMessages import txStates +from dialin.ui import HDSimulator, utils, TXStates from dialin.common.msg_defs import RequestRejectReasons as rejectReason +HDSimulator = HDSimulator() def gotoScreenNtest_Contains_TreatmentHeparinData(): @@ -34,11 +34,11 @@ def test_state(vAccept, vText, vState): mReason = 0 if (not vAccept): mReason = rejectReason.REQUEST_REJECT_REASON_HEPARIN_PRESTOP_EXCEEDS_DURATION.value - denaliMessages.setHeparinResponse(vAccept, mReason, vState) + HDSimulator.cmd_set_heparin_pause_resume_response(vAccept, mReason, vState) utils.waitForGUI(0.2) heparin_button = findObject(names.o_treatmentStart_HeparinPause) # heparin button is not always enable for click - if vState == txStates.HEPARIN_STATE_DISPENSING or vState == txStates.HEPARIN_STATE_PAUSED or vState == txStates.HEPARIN_STATE_COMPLETED : + if vState == TXStates.HEPARIN_STATE_DISPENSING or vState == TXStates.HEPARIN_STATE_PAUSED or vState == TXStates.HEPARIN_STATE_COMPLETED : if not heparin_button is None: test.compare(heparin_button.enabled, True) mouseClick(heparin_button) @@ -58,50 +58,50 @@ gotoScreenNtest_Contains_TreatmentHeparinData() # set the Treatment to running state, otherwise the heparin section will be disabled. - denaliMessages.setTreatmentStatesData(txStates.TREATMENT_DIALYSIS_STATE, txStates.UF_OFF_STATE, txStates.SALINE_BOLUS_STATE_IDLE, txStates.HEPARIN_STATE_OFF) + HDSimulator.cmd_set_treatment_states_data(TXStates.TREATMENT_DIALYSIS_STATE, TXStates.UF_OFF_STATE, TXStates.SALINE_BOLUS_STATE_IDLE, TXStates.HEPARIN_STATE_OFF) # it is not working upon user request so there is not rejection # Initial OFF => BOLUS -> Bolus/HEPARIN - test_state(True, "HEPARIN" , txStates.HEPARIN_STATE_INITIAL_BOLUS ) + test_state(True, "HEPARIN" , TXStates.HEPARIN_STATE_INITIAL_BOLUS ) # it is not working upon user request so there is not rejection # Now BOLUS => DISPENSING -> Dispensing/PAUSE - test_state(True, "PAUSE" , txStates.HEPARIN_STATE_DISPENSING ) + test_state(True, "PAUSE" , TXStates.HEPARIN_STATE_DISPENSING ) # Now Dispensing => Paused => Rejected -> Dispensing/PAUSE - test_state(False, "PAUSE" , txStates.HEPARIN_STATE_DISPENSING ) + test_state(False, "PAUSE" , TXStates.HEPARIN_STATE_DISPENSING ) # Retry Dispensing => Paused => Rejected -> Dispensing/PAUSE - test_state(False, "PAUSE" , txStates.HEPARIN_STATE_DISPENSING ) + test_state(False, "PAUSE" , TXStates.HEPARIN_STATE_DISPENSING ) # Still Dispensing => paused => Accepted -> Paused/RESUME - test_state(True, "RESUME" , txStates.HEPARIN_STATE_PAUSED ) + test_state(True, "RESUME" , TXStates.HEPARIN_STATE_PAUSED ) # Now Paused => Dispensing => Rejected -> Paused/RESUME - test_state(False, "RESUME" , txStates.HEPARIN_STATE_PAUSED ) + test_state(False, "RESUME" , TXStates.HEPARIN_STATE_PAUSED ) # Retry Paused => Dispensing => Rejected -> Paused/RESUME - test_state(False, "RESUME" , txStates.HEPARIN_STATE_PAUSED ) + test_state(False, "RESUME" , TXStates.HEPARIN_STATE_PAUSED ) # Still Paused => Dispensing => Accepted -> Dispensing/PAUSE - test_state(True , "PAUSE" , txStates.HEPARIN_STATE_DISPENSING ) + test_state(True , "PAUSE" , TXStates.HEPARIN_STATE_DISPENSING ) # it is not working upon user request so there is not rejection # Now Dispensing => Complete -> Complete/RESUME - test_state(True, "RESUME" , txStates.HEPARIN_STATE_COMPLETED ) + test_state(True, "RESUME" , TXStates.HEPARIN_STATE_COMPLETED ) # Now Complete => Dispensing => Rejected -> Complete/RESUME - test_state(False, "RESUME" , txStates.HEPARIN_STATE_COMPLETED ) + test_state(False, "RESUME" , TXStates.HEPARIN_STATE_COMPLETED ) # Retry Complete => Dispensing => Rejected -> Complete/RESUME - test_state(False, "RESUME" , txStates.HEPARIN_STATE_COMPLETED ) + test_state(False, "RESUME" , TXStates.HEPARIN_STATE_COMPLETED ) # Still Complete => Dispensing => Accepted -> Dispensing/PAUSE - test_state(True, "PAUSE" , txStates.HEPARIN_STATE_DISPENSING ) + test_state(True, "PAUSE" , TXStates.HEPARIN_STATE_DISPENSING ) # it is not working upon user request so there is not rejection # the dispensing to pause retry tested above and we assume it will deliver until is empty # Now Dispensing => Empty => -> Dispensing/PAUSE - test_state(True, "HEPARIN" , txStates.HEPARIN_STATE_EMPTY ) + test_state(True, "HEPARIN" , TXStates.HEPARIN_STATE_EMPTY ) utils.tstDone() Index: tst_Treatment_Adjustment_Ultrafiltration/test.py =================================================================== diff -u -rab2ebd8c7b5c8df145c2b8cc06a397258ecf2f13 -r310f51a5ed4921f184572f90d07b350ec41c0bae --- tst_Treatment_Adjustment_Ultrafiltration/test.py (.../test.py) (revision ab2ebd8c7b5c8df145c2b8cc06a397258ecf2f13) +++ tst_Treatment_Adjustment_Ultrafiltration/test.py (.../test.py) (revision 310f51a5ed4921f184572f90d07b350ec41c0bae) @@ -13,9 +13,11 @@ # import names -from dialin.squish import utils, denaliMessages -from dialin.squish.denaliMessages import txStates +from dialin.ui import utils +from dialin import HDSimulator +from dialin.ui.hd_simulator import TXStates from dialin.common.msg_defs import RequestRejectReasons as rejectReason +HDSimulator = HDSimulator() eInvalid = 0 @@ -61,7 +63,7 @@ def startNTestTreatmentUltrafiltration(vMinUF, vMaxUF): for i in range(vMinUF, vMaxUF+1, 10): - denaliMessages.setTreatmentUltrafiltration(vMaxUF, i, 1, 1, 1, 1, 1) + HDSimulator.cmd_set_treatment_ultrafiltration_outlet_flow_data(vMaxUF, i, 1, 1, 1, 1, 1) test.compare(utils.l2ml(waitForObjectExists(names.o_treatmentStart_ultrafiltrationTouchArea_TreatmentUltrafiltration).value), i) @@ -105,14 +107,14 @@ # [Normal Notification] test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationStart_NotificationBar).text), "") # [Reject Pause] - denaliMessages.setTreatmentAdjustUltrafiltrationRejected(rejectReason.REQUEST_REJECT_REASON_UF_NOT_IN_PROGESS.value, txStates.UF_RUNNING_STATE) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_rejected(rejectReason.REQUEST_REJECT_REASON_UF_NOT_IN_PROGESS.value, TXStates.UF_RUNNING_STATE) # [Reject Notification] test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationStart_NotificationBar).text), rejectReason.REQUEST_REJECT_REASON_UF_NOT_IN_PROGESS.name) def pause_Accept(): # [Accept Pause] - denaliMessages.setTreatmentAdjustUltrafiltrationAccepted(txStates.UF_PAUSED_STATE) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_accepted(TXStates.UF_PAUSED_STATE) # [Accept Notification] test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationPaused_NotificationBar).text), "") utils.waitForGUI(1) @@ -139,14 +141,14 @@ # [Normal Notification] test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationPaused_NotificationBar).text), "") # [Reject Resume] - denaliMessages.setTreatmentAdjustUltrafiltrationRejected(rejectReason.REQUEST_REJECT_REASON_UF_NOT_PAUSED.value, txStates.UF_PAUSED_STATE) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_rejected(rejectReason.REQUEST_REJECT_REASON_UF_NOT_PAUSED.value, TXStates.UF_PAUSED_STATE) # [Reject Notification] test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationPaused_NotificationBar).text), rejectReason.REQUEST_REJECT_REASON_UF_NOT_PAUSED.name) def resume_Accept(): # [Accept Resume] - denaliMessages.setTreatmentAdjustUltrafiltrationAccepted(txStates.UF_RUNNING_STATE) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_accepted(TXStates.UF_RUNNING_STATE) utils.waitForGUI(1) @@ -177,15 +179,15 @@ def edit_RejectNTest(): - denaliMessages.setTreatmentAdjustUltrafiltrationEditRejected(rejectReason.REQUEST_REJECT_REASON_UF_RATE_OUT_OF_RANGE.value) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_edit_rejected(rejectReason.REQUEST_REJECT_REASON_UF_RATE_OUT_OF_RANGE.value) test.compare( waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationEdit_NotificationBar).visible, True) #this error message needs to be changed later when translated. test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationEdit_NotificationBar).text), rejectReason.REQUEST_REJECT_REASON_UF_RATE_OUT_OF_RANGE.name) def updateNTest_Adjustment_Ranges(vMinUFVolume, vMaxUFVolume): # HD sends Ultrafiltration ranges - denaliMessages.setTreatmentParamRanges(0, 0, vMinUFVolume, vMaxUFVolume, 0, 0) + HDSimulator.cmd_set_treatment_parameter_ranges(0, 0, vMinUFVolume, vMaxUFVolume, 0, 0) # Edit Screen updates Ultrafiltration ranges on Slider upon Receiving Ranges test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationEdit_VolumeSlider).minText.text), "{:.3f}".format(utils.ml2l(vMinUFVolume))) test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationEdit_VolumeSlider).maxText.text), "{:.3f}".format(utils.ml2l(vMaxUFVolume))) @@ -201,7 +203,7 @@ def adjustmentResponse(): - denaliMessages.setTreatmentAdjustUltrafiltrationEditResponse(_Accepted, _Reason, _Volume, _Duration, _DurationDiff, _Rate, _RateDiff, _RateOld) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_edit_response(_Accepted, _Reason, _Volume, _Duration, _DurationDiff, _Rate, _RateDiff, _RateOld) def next_Accepted(vVolume, vRateState, vDurationState): @@ -319,19 +321,19 @@ def confirm_RejectNTest(): - denaliMessages.setTreatmentAdjustUltrafiltrationConfirmRejected(rejectReason.REQUEST_REJECT_REASON_TIMEOUT_WAITING_FOR_USER_CONFIRM.value) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_confirm_rejected(rejectReason.REQUEST_REJECT_REASON_TIMEOUT_WAITING_FOR_USER_CONFIRM.value) test.compare( waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationConfirm_NotificationBar).visible, True) test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationConfirm_NotificationBar).text ), rejectReason.REQUEST_REJECT_REASON_TIMEOUT_WAITING_FOR_USER_CONFIRM.name) def confirm_RejectNTest_Unknow(): - denaliMessages.setTreatmentAdjustUltrafiltrationConfirmRejected(200) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_confirm_rejected(200) test.compare( waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationConfirm_NotificationBar).visible, True) test.compare(str(waitForObjectExists(names.o_treatmentAdjustmentUltrafiltrationConfirm_NotificationBar).text ), "[200] Unknown Error") def confirm_Accept(vVolume, vDuration, vRate): - denaliMessages.setTreatmentAdjustUltrafiltrationConfirmResponse(1, 0, vVolume, vDuration, vRate) + HDSimulator.cmd_set_treatment_adjust_ultrafiltration_confirm_response(1, 0, vVolume, vDuration, vRate) def main(): @@ -353,7 +355,7 @@ closeScreen() # Back to main # set the ultrafiltration to running state - denaliMessages.setTreatmentStatesData(txStates.TREATMENT_DIALYSIS_STATE_NOT, txStates.UF_RUNNING_STATE, txStates.SALINE_BOLUS_STATE_IDLE, txStates.HEPARIN_STATE_OFF) + HDSimulator.cmd_set_treatment_states_data(TXStates.TREATMENT_DIALYSIS_STATE_NOT, TXStates.UF_RUNNING_STATE, TXStates.SALINE_BOLUS_STATE_IDLE, TXStates.HEPARIN_STATE_OFF) gotoScreen_UltrafiltrationAdjustment()