Index: shared/scripts/names.py =================================================================== diff -u -r2b0ff4367443cf0458594c81c32598df5b6c39cb -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- shared/scripts/names.py (.../names.py) (revision 2b0ff4367443cf0458594c81c32598df5b6c39cb) +++ shared/scripts/names.py (.../names.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -396,7 +396,7 @@ 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"} @@ -424,5 +424,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/heparin/loader.py =================================================================== diff -u --- simulator/plugins/heparin/loader.py (revision 0) +++ simulator/plugins/heparin/loader.py (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -0,0 +1,99 @@ +""" +The Heparin ui loader class +""" +from runtimewidget import RunTimeWidget +from PySide2 import QtWidgets +from PySide2.QtCore import Slot +from dialin.ui.hd_simulator import TXStates +from dialin.ui import HDSimulator + + +class Heparin(RunTimeWidget): + """ + The Saline Bolus ui loader class + """ + + btnAccept: QtWidgets.QPushButton + btnReject: QtWidgets.QPushButton + lblAction: QtWidgets.QLabel + lblCumulative: QtWidgets.QLabel + spnRejectReason: QtWidgets.QSpinBox + sldCumulative: QtWidgets.QSlider + + requested_state: TXStates + + def __init__(self): + super().__init__("plugins/heparin/interface.ui") + self.requested_state = TXStates.HEPARIN_STATE_PAUSED + self.initialize() + self.init_widgets() + self.init_connections() + self.hd_simulator = HDSimulator() + + def initialize(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.lblCumulative = self.find_label('lblCumulative') + self.spnRejectReason = self.find_spinbox('spnRejectReason') + # saline data + self.sldCumulative = self.find_slider('sldCumulative') + + def init_widgets(self): + """ + initializes the widgets' properties + :return: none + """ + pass + + def init_connections(self): + """ + initializes the widgets connections + :return: + """ + # saline adjustment + self.btnAccept.clicked.connect(self.do_accept) + self.btnReject.clicked.connect(self.do_reject) + # saline data + self.sldCumulative.valueChanged.connect(self.do_data) + + @Slot() + def do_accept(self): + """ + the slot for accept button + :return: none + """ + # toggle the requested state + if self.requested_state == TXStates.HEPARIN_STATE_DISPENSING: + self.requested_state = TXStates.HEPARIN_STATE_PAUSED + else: + self.requested_state = TXStates.HEPARIN_STATE_DISPENSING + + self.hd_simulator.setHeparinResponse(True, 0, self.requested_state) + 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.setHeparinResponse(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.setTreatmentHeparinData(volume) + self.lblCumulative.setNum(volume) Index: simulator/plugins/inlinebloodpressures/loader.py =================================================================== diff -u --- simulator/plugins/inlinebloodpressures/loader.py (revision 0) +++ simulator/plugins/inlinebloodpressures/loader.py (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -0,0 +1,164 @@ +""" +The In-Line Blood Pressure ui class +""" + +from runtimewidget import RunTimeWidget +from PySide2 import QtWidgets +from PySide2.QtCore import QObject, Slot +from dialin.common import Ranges +from dialin.ui import HDSimulator, TXStates, EResponse + + +class InlineBloodPressures(RunTimeWidget): + """ + The In-Line Blood Pressure ui class + """ + btnAVPressuresAccept: QtWidgets.QPushButton + btnAVPressuresReject: QtWidgets.QPushButton + + lblArterialTitle: QtWidgets.QLabel + lblVenousTitle: QtWidgets.QLabel + lblAVPressuresAction: QtWidgets.QLabel + lblArterialLimitLow: QtWidgets.QLabel + lblArterialLimitHigh: QtWidgets.QLabel + lblVenousLimitLow: QtWidgets.QLabel + lblVenousLimitHigh: QtWidgets.QLabel + + spnAVPressuresRejectReason: QtWidgets.QSpinBox + spnArterialLimitLow: QtWidgets.QSpinBox + spnArterialLimitHigh: QtWidgets.QSpinBox + spnVenousLimitLow: QtWidgets.QSpinBox + spnVenousLimitHigh: QtWidgets.QSpinBox + + sldArterialValue: QtWidgets.QSlider + sldVenousValue: QtWidgets.QSlider + + def __init__(self): + super().__init__("plugins/inlinebloodpressures/interface.ui") + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IDLE + self.initialize() + self.init_widgets() + self.init_connections() + self.hd_simulator = HDSimulator() + + def initialize(self): + """ + finds and creates widgets + :return: none + """ + self.lblArterialTitle = self.find_label('lblArterialTitle') + self.lblVenousTitle = self.find_label('lblVenousTitle') + self.lblArterialLimitLow = self.find_label('lblArterialLimitLow') + self.lblArterialLimitHigh = self.find_label('lblArterialLimitHigh') + self.lblVenousLimitLow = self.find_label('lblVenousLimitLow') + self.lblVenousLimitHigh = self.find_label('lblVenousLimitHigh') + self.lblAVPressuresAction = self.find_label('lblAVPressuresAction') + + self.btnAVPressuresAccept = self.find_button('btnAVPressuresAccept') + self.btnAVPressuresReject = self.find_button('btnAVPressuresReject') + + self.spnArterialLimitLow = self.find_spinbox('spnArterialLimitLow') + self.spnArterialLimitHigh = self.find_spinbox('spnArterialLimitHigh') + self.spnVenousLimitLow = self.find_spinbox('spnVenousLimitLow') + self.spnVenousLimitHigh = self.find_spinbox('spnVenousLimitHigh') + self.spnAVPressuresRejectReason = self.find_spinbox('spnAVPressuresRejectReason') + + self.sldArterialValue = self.find_slider('sldArterialValue') + self.sldVenousValue = self.find_slider('sldVenousValue') + + def init_widgets(self): + """ + initializes the widgets' properties + :return: none + """ + self.lblArterialTitle.setText( + f"{self.lblArterialTitle.text()} [{Ranges.ARTERIAL_PRESSURE_MINIMUM},{Ranges.ARTERIAL_PRESSURE_MAXIMUM}]" + ) + self.lblVenousTitle.setText( + f"{self.lblVenousTitle.text()} [{Ranges.VENOUS_PRESSURE_MINIMUM},{Ranges.VENOUS_PRESSURE_MAXIMUM}]" + ) + + self.lblArterialLimitLow.setText(f"{Ranges.ARTERIAL_PRESSURE_LOW_MIN}\n{Ranges.ARTERIAL_PRESSURE_LOW_MAX}") + self.lblArterialLimitHigh.setText(f"{Ranges.ARTERIAL_PRESSURE_HIGH_MIN}\n{Ranges.ARTERIAL_PRESSURE_HIGH_MAX}") + self.lblVenousLimitLow.setText(f"{Ranges.VENOUS_PRESSURE_LOW_MIN}\n{Ranges.VENOUS_PRESSURE_LOW_MAX}") + self.lblVenousLimitHigh.setText(f"{Ranges.VENOUS_PRESSURE_HIGH_MIN}\n{Ranges.VENOUS_PRESSURE_HIGH_MAX}") + + self.sldArterialValue.setMinimum(Ranges.ARTERIAL_PRESSURE_MINIMUM) + self.sldArterialValue.setMaximum(Ranges.ARTERIAL_PRESSURE_MAXIMUM) + self.sldArterialValue.setValue(0) + self.sldVenousValue.setMinimum(Ranges.VENOUS_PRESSURE_MINIMUM) + self.sldVenousValue.setMaximum(Ranges.VENOUS_PRESSURE_MAXIMUM) + self.sldVenousValue.setValue(0) + + self.spnArterialLimitLow.setMinimum(Ranges.ARTERIAL_PRESSURE_LOW_MIN) + self.spnArterialLimitLow.setMaximum(Ranges.ARTERIAL_PRESSURE_LOW_MAX) + self.spnArterialLimitLow.setValue(Ranges.ARTERIAL_PRESSURE_LOW_DEF) + + self.spnArterialLimitHigh.setMinimum(Ranges.ARTERIAL_PRESSURE_HIGH_MIN) + self.spnArterialLimitHigh.setMaximum(Ranges.ARTERIAL_PRESSURE_HIGH_MAX) + self.spnArterialLimitHigh.setValue(Ranges.ARTERIAL_PRESSURE_HIGH_DEF) + + self.spnVenousLimitLow.setMinimum(Ranges.VENOUS_PRESSURE_LOW_MIN) + self.spnVenousLimitLow.setMaximum(Ranges.VENOUS_PRESSURE_LOW_MAX) + self.spnVenousLimitLow.setValue(Ranges.VENOUS_PRESSURE_LOW_DEF) + + self.spnVenousLimitHigh.setMinimum(Ranges.VENOUS_PRESSURE_HIGH_MIN) + self.spnVenousLimitHigh.setMaximum(Ranges.VENOUS_PRESSURE_HIGH_MAX) + self.spnVenousLimitHigh.setValue(Ranges.VENOUS_PRESSURE_HIGH_DEF) + + def init_connections(self): + """ + initializes the widgets connections + :return: none + """ + # sending the CANBus message when slider value changed + self.sldArterialValue.valueChanged.connect(self.do_pressures_data) + self.sldVenousValue.valueChanged.connect(self.do_pressures_data) + + # sending the CANBus message when accepted or rejected + self.btnAVPressuresAccept.clicked.connect(self.do_pressures_limits_accept) + self.btnAVPressuresReject.clicked.connect(self.do_pressures_limits_reject) + + @Slot() + def do_pressures_data(self): + """ + sends the pressures values message with given value on the screen + :return: none + """ + self.hd_simulator.cmd_set_pressure_occlusion_data( + self.sldArterialValue.value(), + self.sldVenousValue.value(), + 0, 0, 0 + ) + + @Slot() + def do_pressures_limits_accept(self): + """ + sends the pressures values message with given value on the screen + :return: none + """ + # vAccepted, vReason, vArterialLow, vArterialHigh, vVenousLow, vVenousHigh + self.hd_simulator.sendTreatmentAdjustPressuresLimitsResponse( + EResponse.Accepted, 0, + self.spnArterialLimitLow.value(), + self.spnArterialLimitHigh.value(), + self.spnVenousLimitLow.value(), + self.spnVenousLimitHigh.value() + ) + self.lblAVPressuresAction.setText('Accepted ') + + @Slot() + def do_pressures_limits_reject(self): + """ + sends the pressures values message with given value on the screen + :return: none + """ + reason = self.spnAVPressuresRejectReason.value() + self.hd_simulator.sendTreatmentAdjustPressuresLimitsResponse( + EResponse.Rejected, reason, + self.spnArterialLimitLow.value(), + self.spnArterialLimitHigh.value(), + self.spnVenousLimitLow.value(), + self.spnVenousLimitHigh.value() + ) + self.lblAVPressuresAction.setText('Rejected ' + "{}".format(reason)) Index: simulator/plugins/salinebolus/loader.py =================================================================== diff -u --- simulator/plugins/salinebolus/loader.py (revision 0) +++ simulator/plugins/salinebolus/loader.py (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -0,0 +1,106 @@ +""" +The Saline Bolus ui loader class +""" +from runtimewidget import RunTimeWidget +from PySide2 import QtWidgets +from PySide2.QtCore import Slot +from dialin.ui import HDSimulator, TXStates + + +class SalineBolus(RunTimeWidget): + """ + The Saline Bolus ui loader class + """ + + btnSalineAccept: QtWidgets.QPushButton + btnSalineReject: QtWidgets.QPushButton + lblSalineAction: QtWidgets.QLabel + spnSalineRejectReason: QtWidgets.QSpinBox + cmbSalineAcceptTarget: QtWidgets.QComboBox + sldSalineTarget: QtWidgets.QSlider + sldSalineCumulative: QtWidgets.QSlider + sldSalineVolume: QtWidgets.QSlider + + saline_requested_state: TXStates + + def __init__(self): + super().__init__("plugins/salinebolus/interface.ui") + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IDLE + self.initialize() + self.init_widgets() + self.init_connections() + self.hd_simulator = HDSimulator() + + def initialize(self): + """ + finds and creates widgets + :return: none + """ + # saline adjustment + self.btnSalineAccept = self.find_button('btnSalineAccept') + self.btnSalineReject = self.find_button('btnSalineReject') + self.lblSalineAction = self.find_label('lblSalineAction') + self.spnSalineRejectReason = self.find_spinbox('spnSalineRejectReason') + self.cmbSalineAcceptTarget = self.find_combobox('cmbSalineAcceptTarget') + # saline data + self.sldSalineTarget = self.find_slider('sldSalineTarget') + self.sldSalineCumulative = self.find_slider('sldSalineCumulative') + self.sldSalineVolume = self.find_slider('sldSalineVolume') + + def init_widgets(self): + """ + initializes the widgets' properties + :return: none + """ + pass + + def init_connections(self): + """ + initializes the widgets connections + :return: + """ + # saline adjustment + self.btnSalineAccept.clicked.connect(self.do_sb_accept) + self.btnSalineReject.clicked.connect(self.do_sb_reject) + # saline data + self.sldSalineTarget.valueChanged.connect(self.do_saline_data) + self.sldSalineCumulative.valueChanged.connect(self.do_saline_data) + self.sldSalineVolume.valueChanged.connect(self.do_saline_data) + + @Slot() + def do_sb_accept(self): + """ + the slot for accept saline bolus button + :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 + else: + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IN_PROGRESS + + target = self.cmbSalineAcceptTarget.currentText() + self.hd_simulator.cmd_set_saline_bolus_response(True, 0, target, self.saline_requested_state) + self.lblSalineAction.setText('Accepted ' + target) + + @Slot() + def do_sb_reject(self): + """ + the slot for accept saline bolus button + :return: none + """ + reason = self.spnSalineRejectReason.value() + self.hd_simulator.cmd_set_saline_bolus_response(False, reason, 0, self.saline_requested_state) + self.lblSalineAction.setText('Rejected ' + "{}".format(reason)) + + + @Slot() + def do_saline_data(self): + """ + the slot which is called to send the saline bolus data + by calling the denaliMessage API setTreatmentSalineBolusData + :return: none + """ + 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 --- simulator/plugins/treatmentranges/loader.py (revision 0) +++ simulator/plugins/treatmentranges/loader.py (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -0,0 +1,90 @@ +""" + The Treatment Ranges ui loader +""" +from runtimewidget import RunTimeWidget +from PySide2 import QtWidgets +from PySide2.QtCore import QTimer +from PySide2.QtCore import Slot +from dialin.ui import HDSimulator + + +class TreatmentRanges(RunTimeWidget): + """ + The Treatment Ranges ui loader + """ + timer: QTimer + + chkRangesBroadcast: QtWidgets.QCheckBox + spnDurationMin: QtWidgets.QSpinBox + spnDurationMax: QtWidgets.QSpinBox + spnDialysateMin: QtWidgets.QSpinBox + spnDialysateMax: QtWidgets.QSpinBox + spnUFVolumeMin: QtWidgets.QSpinBox + spnUFVolumeMax: QtWidgets.QSpinBox + sldDurationValue: QtWidgets.QSlider + + def __init__(self): + super().__init__("plugins/treatmentranges/interface.ui") + self.initialize() + self.init_widgets() + self.init_connections() + self.hd_simulator = HDSimulator() + + def initialize(self): + """ + finds and creates widgets + :return: none + """ + self.spnDurationMin = self.find_spinbox('spnDurationMin') + self.spnDurationMax = self.find_spinbox('spnDurationMax') + self.sldDurationValue = self.find_slider('sldDurationValue') + self.spnUFVolumeMin = self.find_spinbox('spnUFVolumeMin') + self.spnUFVolumeMax = self.find_spinbox('spnUFVolumeMax') + self.spnDialysateMin = self.find_spinbox('spnDialysateMin') + self.spnDialysateMax = self.find_spinbox('spnDialysateMax') + self.chkRangesBroadcast = self.find_checkbox('chkRangesBroadcast') + + def init_connections(self): + """ + initializes the widgets connections + :return: none + """ + self.timer.timeout.connect(self.do_ranges_data) + self.sldDurationValue.valueChanged.connect(self.do_duration_data) + + def init_widgets(self): + """ + initializes the widgets' properties + :return: none + """ + self.timer = QTimer() + self.timer.start(1000) + + @Slot() + def do_duration_data(self, value): + """ + sends the duration message + :return: none + """ + self.hd_simulator.cmd_set_treatment_time(self.spnDurationMax.value() * 60, value) + + @Slot() + def do_ranges_data(self): + """ + sends the treatment ranges message with given value on the screen + :return: none + """ + if self.chkRangesBroadcast.isChecked(): + duration_min = self.spnDurationMin.value() + duration_max = self.spnDurationMax.value() + self.sldDurationValue.setMinimum(duration_min * 60) + self.sldDurationValue.setMaximum(duration_max * 60) + + self.hd_simulator.cmd_set_treatment_parameter_ranges( + duration_min, + duration_max, + self.spnUFVolumeMin.value(), + self.spnUFVolumeMax.value(), + self.spnDialysateMin.value(), + self.spnDialysateMax.value() + ) Index: simulator/plugins/treatmentstates/loader.py =================================================================== diff -u --- simulator/plugins/treatmentstates/loader.py (revision 0) +++ simulator/plugins/treatmentstates/loader.py (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -0,0 +1,69 @@ +""" + The Ultrafiltration ui loader +""" +from runtimewidget import RunTimeWidget +from PySide2 import QtWidgets +from PySide2.QtCore import Slot +from dialin.ui import HDSimulator, TXStates + + +class TreatmentStates(RunTimeWidget): + """ + The Ultrafiltration ui loader + """ + tblSubMode: QtWidgets.QTableWidget + tblUFStates: QtWidgets.QTableWidget + tblSalineStates: QtWidgets.QTableWidget + tblHeparinStates: QtWidgets.QTableWidget + + def __init__(self): + super().__init__("plugins/treatmentstates/interface.ui") + self.initialize() + self.init_widgets() + self.init_connections() + self.hd_simulator = HDSimulator() + + # apply/send the initial states + self.do_treatment_states() + + def initialize(self): + """ + finds and creates widgets + :return: none + """ + self.tblSubMode = self.find_table_widget('tblSubMode') + self.tblUFStates = self.find_table_widget('tblUFStates') + self.tblSalineStates = self.find_table_widget('tblSalineStates') + self.tblHeparinStates = self.find_table_widget('tblHeparinStates') + + def init_connections(self): + """ + initializes the widgets connections + :return: none + """ + self.tblSubMode.cellClicked.connect(self.do_treatment_states) + self.tblUFStates.cellClicked.connect(self.do_treatment_states) + self.tblSalineStates.cellClicked.connect(self.do_treatment_states) + self.tblHeparinStates.cellClicked.connect(self.do_treatment_states) + + def init_widgets(self): + """ + 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) + + @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() + self.hd_simulator.setTreatmentStatesData(sub_mode, uf_state, saline, heparin) Index: simulator/plugins/ultrafiltration/loader.py =================================================================== diff -u --- simulator/plugins/ultrafiltration/loader.py (revision 0) +++ simulator/plugins/ultrafiltration/loader.py (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -0,0 +1,148 @@ +""" + The Ultrafiltration ui loader +""" +from runtimewidget import RunTimeWidget +from PySide2 import QtWidgets +from PySide2.QtCore import Slot +from dialin.ui import HDSimulator, TXStates, EResponse + + +class Ultrafiltration(RunTimeWidget): + """ + The Ultrafiltration ui loader + """ + + # components + btnUfPauseAccept: QtWidgets.QPushButton + btnUfPauseReject: QtWidgets.QPushButton + btnUfResumeAccept: QtWidgets.QPushButton + btnUfResumeReject: QtWidgets.QPushButton + btnUfEditAccept: QtWidgets.QPushButton + btnUfEditReject: QtWidgets.QPushButton + + lblUfPauseAction: QtWidgets.QLabel + lblUfResumeAction: QtWidgets.QLabel + lblUfEditAction: QtWidgets.QLabel + + spnUfPauseRejectReason: QtWidgets.QSpinBox + spnUfEditRejectReason: QtWidgets.QSpinBox + spnUfResumeRejectReason: QtWidgets.QSpinBox + sldUfVolume: QtWidgets.QSlider + + def __init__(self): + super().__init__("plugins/ultrafiltration/interface.ui") + self.initialize() + self.init_widgets() + self.init_connections() + self.hd_simulator = HDSimulator() + + def initialize(self): + """ + finds and creates widgets + :return: none + """ + self.btnUfPauseAccept = self.find_button('btnUfPauseAccept') + self.btnUfPauseReject = self.find_button('btnUfPauseReject') + self.btnUfResumeAccept = self.find_button('btnUfResumeAccept') + self.btnUfResumeReject = self.find_button('btnUfResumeReject') + self.btnUfEditAccept = self.find_button('btnUfEditAccept') + self.btnUfEditReject = self.find_button('btnUfEditReject') + self.lblUfPauseAction = self.find_label('lblUfPauseAction') + self.lblUfResumeAction = self.find_label('lblUfResumeAction') + self.lblUfEditAction = self.find_label('lblUfEditAction') + self.spnUfPauseRejectReason = self.find_spinbox('spnUfPauseRejectReason') + self.spnUfResumeRejectReason = self.find_spinbox('spnUfResumeRejectReason') + self.spnUfEditRejectReason = self.find_spinbox('spnUfEditRejectReason') + self.sldUfVolume = self.find_slider('sldUfVolume') + + def init_widgets(self): + """ + initializes the widgets' properties + :return: none + """ + pass + + def init_connections(self): + """ + initializes the widgets connections + :return: none + """ + self.btnUfPauseAccept.clicked.connect(self.do_uf_pause_accept) + self.btnUfPauseReject.clicked.connect(self.do_uf_pause_reject) + self.btnUfResumeAccept.clicked.connect(self.do_uf_resume_accept) + self.btnUfResumeReject.clicked.connect(self.do_uf_resume_reject) + self.btnUfEditAccept.clicked.connect(self.do_uf_edit_accept) + self.btnUfEditReject.clicked.connect(self.do_uf_edit_reject) + self.sldUfVolume.valueChanged.connect(self.do_uf_volume_data) + + @Slot() + def do_uf_pause_accept(self): + """ + the slot for accept ultrafiltration pause button + :return: none + """ + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Accepted, 0, TXStates.UF_PAUSED_STATE) + self.lblUfPauseAction.setText('Accepted ') + + @Slot() + def do_uf_pause_reject(self): + """ + the slot for reject ultrafiltration pause button + :return: none + """ + reason = self.spnUfPauseRejectReason.value() + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Rejected, reason, TXStates.UF_RUNNING_STATE) + self.lblUfPauseAction.setText('Rejected ' + "{}".format(reason)) + + @Slot() + def do_uf_resume_accept(self): + """ + the slot for accept ultrafiltration resume accept + :return: none + """ + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Accepted, 0, TXStates.UF_RUNNING_STATE) + self.lblUfResumeAction.setText('Accepted ') + + @Slot() + def do_uf_resume_reject(self): + """ + the slot for reject ultrafiltration resume button + :return: none + """ + reason = self.spnUfResumeRejectReason.value() + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_state_response( + EResponse.Rejected, reason, TXStates.UF_PAUSED_STATE) + self.lblUfResumeAction.setText('Rejected ' + "{}".format(reason)) + + @Slot() + def do_uf_edit_accept(self): + """ + the slot for accept ultrafiltration next button + :return: none + """ + self.hd_simulator.cmd_set_treatment_adjust_ultrafiltration_edit_response( + EResponse.Accepted, 0, 2500, 60, 0, 10, 0, 10) + self.lblUfEditAction.setText('Accepted ') + + @Slot() + def do_uf_edit_reject(self): + """ + the slot for reject ultrafiltration next button + :return: none + """ + reason = self.spnUfEditRejectReason.value() + 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)) + + @Slot() + def do_uf_volume_data(self): + """ + sends the ultrafiltration delivered volume message + :return: none + """ + self.hd_simulator.cmd_set_treatment_ultrafiltration_outlet_flow_data(self.sldUfVolume.value(), 0, 0, 0, 0, 0, 0) + Index: simulator/run.py =================================================================== diff -u -rc13dc6ba2410716a3f1c446e564085aeb9114a60 -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- simulator/run.py (.../run.py) (revision c13dc6ba2410716a3f1c446e564085aeb9114a60) +++ simulator/run.py (.../run.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -2,19 +2,20 @@ import sys # import project classes -# import names -from dialin.squish import utils -from dialin.squish.denaliMessages import txStates +from dialin.ui import utils +from dialin import HDSimulator +from dialin.ui.hd_simulator import TXStates, EResponse # Import PySide2 classes from PySide2 import QtCore, QtWidgets from PySide2.QtCore import Qt - from runtimewidget import RunTimeWidget # later it's planed to load all the classes in plugin folder dynamically # so used * in here to load all from plugins import * +HDSimulator = HDSimulator() + class Simulator(RunTimeWidget): """ The simulator class which loads the ui file dynamically and initializes the objects @@ -55,7 +56,7 @@ def __init__(self): super().__init__("simulator.ui") - self.saline_requested_state = txStates.SALINE_BOLUS_STATE_IDLE + self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IDLE self.initialize() self.init_widgets() self.init_connections() @@ -66,7 +67,6 @@ :return: none """ self.mdiArea = self.find_widget(QtWidgets.QMdiArea, 'mdiArea') - # TODO: this section needs to change to go over the folders in the plugins folder and load each automatically self.act_treatmentstates = self.find_action('actTreatmentStates') Index: tst_HomeScreen/test.py =================================================================== diff -u -r2cebcfa1c6995bc48c71bcf7367e2695a8d1cb24 -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- tst_HomeScreen/test.py (.../test.py) (revision 2cebcfa1c6995bc48c71bcf7367e2695a8d1cb24) +++ tst_HomeScreen/test.py (.../test.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -13,7 +13,7 @@ # import names -from dialin.squish import utils +from dialin.ui import utils def main(): Index: tst_ServiceShutdown/test.py =================================================================== diff -u -r2cebcfa1c6995bc48c71bcf7367e2695a8d1cb24 -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- tst_ServiceShutdown/test.py (.../test.py) (revision 2cebcfa1c6995bc48c71bcf7367e2695a8d1cb24) +++ tst_ServiceShutdown/test.py (.../test.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -13,9 +13,10 @@ # import names -from dialin.squish import utils, denaliMessages +from dialin.ui import globals, HDSimulator +from dialin.ui import utils +HDSimulator = HDSimulator() - ################################################################################ # This test need to be changed when the Service screen has been implemented # # This is only checking the functionality exists and it's working # @@ -38,25 +39,25 @@ test.compare(waitForObjectExists(names.o_treatmentHome).visible, True, utils.SRSUI(vSRSUI)) def showNtest_PowerOffDialog(vSRSUI=""): - denaliMessages.show_PowerOffDialog() + HDSimulator.cmd_show_poweroff_dialog() test_PowerOffDialog(vSRSUI) def hideNtest_PowerOffDialog(vSRSUI=""): - denaliMessages.hide_PowerOffDialog() + HDSimulator.cmd_hide_poweroff_dialog() test_PowerOffButton(vSRSUI) def showNtest_PowerOffNotificationDialog(vSRSUI=""): - mSRSUI = utils.SRSUI(vSRSUI) - denaliMessages.show_PowerOffNotificationDialog() + mSRSUI = globals.SRSUI(vSRSUI) + HDSimulator.cmd_show_poweroff_notification_dialog() test.compare(str(waitForObjectExists(names.o_poweroff_notification).baseUrl.path), "/dialogs/AutoHideInfo.qml", mSRSUI + " - Dialog") constantPartOfTheMessage = "System is shutting down" test.compare(str(waitForObjectExists(names.o_poweroff_notification).text)[0:len(constantPartOfTheMessage)], constantPartOfTheMessage, mSRSUI + " - Message Text") utils.waitForGUI(5) # dialog timeout utils.waitForGUI(1) # animation transition def showNtest_PowerOffRejectionDialog(vSRSUI=""): - mSRSUI = utils.SRSUI(vSRSUI) - denaliMessages.show_PowerOffRejectionDialog() + mSRSUI = globals.SRSUI(vSRSUI) + HDSimulator.cmd_show_poweroff_rejection_dialog() test.compare(str(waitForObjectExists(names.o_poweroff_rejection).baseUrl.path), "/dialogs/AutoHideInfo.qml", mSRSUI + " - Dialog") constantPartOfTheMessage = "Cannot shutdown during " # there might be the reason, concatenated at the end of the string. test.compare(str(waitForObjectExists(names.o_poweroff_rejection).text)[0:len(constantPartOfTheMessage)], constantPartOfTheMessage, mSRSUI + " - Message Text") Index: tst_TreatmentSalineData/test.py =================================================================== diff -u -r2b0ff4367443cf0458594c81c32598df5b6c39cb -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- tst_TreatmentSalineData/test.py (.../test.py) (revision 2b0ff4367443cf0458594c81c32598df5b6c39cb) +++ tst_TreatmentSalineData/test.py (.../test.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -14,7 +14,9 @@ import names -from dialin.squish import utils, denaliMessages +from dialin.ui import utils +from dialin import HDSimulator +HDSimulator = HDSimulator() def getUnit(): global saline_unit @@ -54,22 +56,22 @@ cumulitive = 0 step = 1 for target in [100, 200, 300]: - denaliMessages.setTreatmentSalineBolusData(target, 0, 0) + HDSimulator.cmd_set_treatment_saline_bolus_data(target, 0, 0) test_target(target) for value in range ( 0, target, step): cumulitive += step - denaliMessages.setTreatmentSalineBolusData(target, cumulitive, value+1) # 0 is not a step + HDSimulator.cmd_set_treatment_saline_bolus_data(target, cumulitive, value + 1) # 0 is not a step test_values ( cumulitive, value+1) # 0 is not a step - denaliMessages.setTreatmentSalineBolusData(200, 110, 10) + HDSimulator.cmd_set_treatment_saline_bolus_data(200, 110, 10) test_target (200 ) test_values ( 110, 10) - denaliMessages.setTreatmentSalineBolusData(200, 110, 10) + HDSimulator.cmd_set_treatment_saline_bolus_data(200, 110, 10) test_target (200 ) test_values ( 110, 10) - denaliMessages.setTreatmentSalineBolusData( 0, 0, 0) + HDSimulator.cmd_set_treatment_saline_bolus_data(0, 0, 0) test_target ( 0 ) test_values ( 0, 0) Index: tst_TreatmentStatesData/test.py =================================================================== diff -u -r6d01b12355c38d1a14b9aa6fb3578c52928d285b -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- tst_TreatmentStatesData/test.py (.../test.py) (revision 6d01b12355c38d1a14b9aa6fb3578c52928d285b) +++ tst_TreatmentStatesData/test.py (.../test.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -13,69 +13,71 @@ # 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 +HDSimulator = HDSimulator() def gotoScreenNtest_Contains_TreatmentStatesData(): mouseClick(waitForObject(names.o_treatmentHome_startTreatment)) # default state of the in-treatment - test_values(txStates.TREATMENT_DIALYSIS_STATE_NOT , txStates.UF_OFF_STATE , txStates.SALINE_BOLUS_STATE_IDLE, txStates.HEPARIN_STATE_OFF) + test_values(TXStates.TREATMENT_DIALYSIS_STATE_NOT, TXStates.UF_OFF_STATE, TXStates.SALINE_BOLUS_STATE_IDLE, TXStates.HEPARIN_STATE_OFF) def test_values(vSubMode, vUFState, vSalineState, vHeparinState): - denaliMessages.setTreatmentStatesData(vSubMode, vUFState, vSalineState, vHeparinState) + HDSimulator.setTreatmentStatesData(vSubMode, vUFState, vSalineState, vHeparinState) # these test cases are not always depending on each other - if (vSubMode == txStates.TREATMENT_DIALYSIS_STATE_NOT): + if (vSubMode == TXStates.TREATMENT_DIALYSIS_STATE_NOT): test.compare( waitForObjectExists(names.o_treatmentStart_treatmentTime_arrowImage ).visible, False ) test.compare( waitForObjectExists(names.o_treatmentStart_treatmentTime_second ).visible, False ) test.compare( findObject (names.o_treatmentStart_treatmentTime_notification ).visible, True ) - if (vSubMode == txStates.TREATMENT_DIALYSIS_STATE ): + if (vSubMode == TXStates.TREATMENT_DIALYSIS_STATE): test.compare( findObject (names.o_treatmentStart_treatmentTime_arrowImage ).visible, True ) test.compare( findObject (names.o_treatmentStart_treatmentTime_second ).visible, True ) test.compare( waitForObjectExists(names.o_treatmentStart_treatmentTime_notification ).visible, False ) test.compare(str(waitForObjectExists(names.o_treatmentStart_treatmentTime_notification ).text ), "Treatment Paused") - if (vUFState == txStates.UF_OFF_STATE ): + if (vUFState == TXStates.UF_OFF_STATE): test.compare( waitForObjectExists(names.o_treatmentStart_ultrafiltration_notification ).visible , True) test.compare(str(waitForObjectExists(names.o_treatmentStart_ultrafiltration_notification ).text ) , "Ultrafiltration is off" ) - if (vUFState == txStates.UF_PAUSED_STATE ): + if (vUFState == TXStates.UF_PAUSED_STATE): test.compare( waitForObjectExists(names.o_treatmentStart_ultrafiltration_notification ).visible , True) test.compare(str(waitForObjectExists(names.o_treatmentStart_ultrafiltration_notification ).text ) , "Ultrafiltration is paused" ) - if (vUFState == txStates.UF_COMPLETED_STATE ): + if (vUFState == TXStates.UF_COMPLETED_STATE): test.compare( waitForObjectExists(names.o_treatmentStart_ultrafiltration_notification ).visible , True) test.compare(str(waitForObjectExists(names.o_treatmentStart_ultrafiltration_notification ).text ) , "Ultrafiltration is completed" ) - if (vSalineState == txStates.SALINE_BOLUS_STATE_MAX_DELIVERED ): + if (vSalineState == TXStates.SALINE_BOLUS_STATE_MAX_DELIVERED): test.compare( waitForObjectExists(names.o_treatmentStart_SalineSection ).isTouchable, False) test.compare(str(waitForObjectExists(names.o_treatmentStart_SalineStart ).text.text), "START BOLUS") test.compare(str(waitForObjectExists(names.o_treatmentStart_SalineNotification ).text ), "Maximum cumulative saline bolus volume delivered") test.compare( waitForObjectExists(names.o_treatmentStart_SalineNotification ).visible, True) # in all the other cases it should be enabled test.compare(waitForObjectExists(names.o_treatmentStart_SalineStart).text.enabled, - not ( - vSalineState == txStates.SALINE_BOLUS_STATE_MAX_DELIVERED or - vSalineState == txStates.SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP + not ( + vSalineState == TXStates.SALINE_BOLUS_STATE_MAX_DELIVERED or + vSalineState == TXStates.SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP ) ) - if (vSalineState == txStates.SALINE_BOLUS_STATE_IDLE ): + if (vSalineState == TXStates.SALINE_BOLUS_STATE_IDLE): test.compare( waitForObjectExists(names.o_treatmentStart_ultrafiltration_section ).isTouchable, True ) utils.waitForGUI(0.2) mouseClick ( waitForObject (names.o_treatmentStart_ultrafiltration_section)) utils.waitForGUI(0.2) - if (vUFState == txStates.UF_RUNNING_STATE ): + if (vUFState == TXStates.UF_RUNNING_STATE): test.compare( findObject (names.o_treatmentAdjustmentUltrafiltrationStart_Screen ).visible , True ) else: test.compare( findObject (names.o_treatmentAdjustmentUltrafiltrationPaused_Screen ).visible , True ) mouseClick ( waitForObject (names.o_closeButton)) - if (vSalineState == txStates.SALINE_BOLUS_STATE_IN_PROGRESS or vSalineState == txStates.SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP): + if (vSalineState == TXStates.SALINE_BOLUS_STATE_IN_PROGRESS or vSalineState == TXStates.SALINE_BOLUS_STATE_WAIT_FOR_PUMPS_STOP): test.compare( waitForObjectExists(names.o_treatmentStart_ultrafiltration_section ).isTouchable, False ) test.compare( waitForObjectExists(names.o_treatmentStart_HeparinSection ).isTouchable, False ) Index: tst_Treatment_Adjustment_Ultrafiltration/test.py =================================================================== diff -u -r2b0ff4367443cf0458594c81c32598df5b6c39cb -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- tst_Treatment_Adjustment_Ultrafiltration/test.py (.../test.py) (revision 2b0ff4367443cf0458594c81c32598df5b6c39cb) +++ tst_Treatment_Adjustment_Ultrafiltration/test.py (.../test.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -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() Index: tst_Treatment_PressureOcclusion/test.py =================================================================== diff -u -refb0dcc34f39f35d41f43cca9667db17fd97c844 -rcb8d48033154f4b36a6a05b6f31bd10390e84ac7 --- tst_Treatment_PressureOcclusion/test.py (.../test.py) (revision efb0dcc34f39f35d41f43cca9667db17fd97c844) +++ tst_Treatment_PressureOcclusion/test.py (.../test.py) (revision cb8d48033154f4b36a6a05b6f31bd10390e84ac7) @@ -13,7 +13,9 @@ # import names -from dialin.squish import utils, denaliMessages +from dialin.ui import utils +from dialin import HDSimulator +HDSimulator = HDSimulator() def gotoScreenNtest_Contains_PressureOcclusion(): @@ -29,21 +31,21 @@ gotoScreenNtest_Contains_PressureOcclusion() utils.waitForGUI(1) - denaliMessages.setPressureOcclusionData(0, 0, 0, 0, 0) + HDSimulator.cmd_set_pressure_occlusion_data(0, 0, 0, 0, 0) test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).arterilPressure, 0) test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).venousPressure , 0) - denaliMessages.setPressureOcclusionData(200, 100, 50, 25, 15) # Coverage + HDSimulator.cmd_set_pressure_occlusion_data(200, 100, 50, 25, 15) # Coverage test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).arterilPressure, 200) test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).venousPressure , 100) - denaliMessages.setPressureOcclusionData(200, 100, 50, 25, 15) + HDSimulator.cmd_set_pressure_occlusion_data(200, 100, 50, 25, 15) test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).arterilPressure, 200) test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).venousPressure , 100) - denaliMessages.setPressureOcclusionData(0, 0, 0, 0, 0) + HDSimulator.cmd_set_pressure_occlusion_data(0, 0, 0, 0, 0) test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).arterilPressure, 0) test.compare(waitForObjectExists(names.o_treatmentStart_pressureTouchArea_TreatmentPressure).venousPressure , 0)