#!/usr/bin/env python3 # Qtvcp action widget # # Copyright (c) 2017 Chris Morley # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # Action buttons are used to change linuxcnc behavior do to button pushing. # By making the button 'checkable' in the designer editor, # the button will toggle. # In the designer editor, it is possible to select what the button will do. ############################################################################### from qtpy import QtCore import linuxcnc from qtvcp.widgets.widget_baseclass import _HalWidgetBase from qtvcp.widgets.simple_widgets import IndicatedPushButton from qtvcp.core import Status, Action, Info from qtvcp.lib.aux_program_loader import Aux_program_loader from qtvcp import logger # Instantiate the libraries with global reference # STATUS gives us status messages from linuxcnc # ACTION gives commands to linuxcnc # INFO is INI file details # LOG is for running code logging STATUS = Status() ACTION = Action() INFO = Info() AUX_PRGM = Aux_program_loader() LOG = logger.getLogger(__name__) # Force the log level for this module LOG.setLevel(logger.DEBUG) # One of DEBUG, INFO, WARNING, ERROR, CRITICAL DEFAULT = 0 WARNING = 1 CRITICAL = 2 class ActionButton(IndicatedPushButton): def __init__(self, parent=None): super(ActionButton, self).__init__(parent) self._block_signal = False self._designer_block_signal = False self._designer_running = False self._no_action = False self.estop = False self.machine_on = False self.home = False self.unhome = False self.home_select = False self.unhome_select = False self.run = False self.run_from_status = False self.run_from_slot = False self.abort = False self.pause = False self.step = False self.load_dialog = False self.macro_dialog = False self.origin_offset_dialog = False self.tool_offset_dialog = False self.tool_chooser_dialog = False self.camview_dialog = False self.machine_log_dialog = False self.jog_joint_pos = False self.jog_joint_neg = False self.jog_selected_pos = False self.jog_selected_neg = False self.zero_axis = False self.zero_g5x = False self.zero_g92 = False self.zero_zrot = False self.launch_halmeter = False self.launch_status = False self.launch_halshow = False self.launch_halscope = False self.launch_calibration = False self.mdi = False self.auto = False self.manual = False self.jog_incr = False self.jog_rate = False self.feed_over = False self.rapid_over = False self.max_velocity_over = False self.spindle_over = False self.view_change = False self.spindle_fwd = False self.spindle_rev = False self.spindle_stop = False self.spindle_up = False self.spindle_down = False self.limits_override = False self.flood = False self.mist = False self.block_delete = False self.optional_stop = False self.mdi_command = False self.ini_mdi_command = False self.is_in_mdi_mode_check = False self.ini_macro_command = False self.dro_relative = False self.dro_absolute = False self.dro_dtg = False self.exit = False self.template_label = False self.lathe_mirror_x = False self.home_no_unhome = False self.toggle_float = False self._toggle_state = 0 self.joint = -1 self.axis = '' self.jog_incr_imperial = .010 self.jog_incr_mm = .025 self.jog_incr_angle = -1 self.float = 100.0 self.float_alt = 50.0 self.view_type = 'p' self.command_text = '' self.ini_mdi_keystring = '' self.ini_macro_keystring = '' # legacy attribute self.ini_mdi_num = -1 self.ini_macro_num = -1 self._textTemplate = '%1.3f in' self._alt_textTemplate = '%1.2f mm' self._run_from_line_int = 0 # Estop button behaviour works different then most buttons. # The visual cue is set by linuxcnc E-state not button state. # We catch the state change here and reset it to linuxcnc state # only if the button is an estop button and is checkable. # This behaviour is consistent with AXIS ans users are used to it. # spindle up/down also have odd behaviour and are caught here. # if the spindle is already running, pressing the opposite button # should not change the check state (only change the spindle speed) # but if the spindle is running or stopped then the check state # should change (and the spindle speed - done in other code) def nextCheckState (self): if self.estop and self.isCheckable(): if STATUS.estop_is_clear(): self.setChecked(False) else: self.setChecked(True) self._safecheck(not STATUS.estop_is_clear()) return try: speed = STATUS.get_spindle_speed() except: speed = 0 if self.spindle_down and self.isCheckable(): if speed == 0 or speed < 0: self._safecheck(not self.isChecked()) elif self.spindle_up and self.isCheckable(): if speed == 0 or speed > 0: self._safecheck(not self.isChecked()) else: self.setChecked(not self.isChecked()) # only called from designer plugin when widget built in editor def _designer_init(self): self._designer_block_signal = True self._designer_running = True ################################################## # _safecheck blocks the outgoing signal so # the buttons can be synced with linuxcnc # without setting an infinite loop # If the indicator isn't controlled by a HAL pin # then update it's state. # It still might not show do to the draw_indicator option off ################################################### def _safecheck(self, state, data=None): self._block_signal = True self.setChecked(state) # update indicator if halpin or status doesn't if self._HAL_pin is False and self._ind_status is False: self.indicator_update(state) # if using state labels option update the labels if self._state_text: self.setText(None) self._block_signal = False ################################################## # This gets called by qtvcp_makepins # It infers HAL involvement but there is none # STATUS is used to sync the buttons in case # other entities change linuxcnc's state # also some buttons are disabled/enabled based on # linuxcnc state / possible actions # # super()._hal_init() initializes parent classes ################################################### def _hal_init(self): super()._hal_init() def _checkincrements(value, text): value = round(value , 5) if STATUS.is_metric_mode(): machn_units = INFO.convert_metric_to_machine(self.jog_incr_mm) if round(machn_units , 5) == value: self._safecheck(True) return else: machn_units = INFO.convert_imperial_to_machine(self.jog_incr_imperial) if round(machn_units , 5) == value: self._safecheck(True) return self._safecheck(False) def homed_on_loaded_test(): return (STATUS.machine_is_on() and (STATUS.is_all_homed() or INFO.NO_HOME_REQUIRED) and STATUS.is_file_loaded()) def homed_on_test(): return (STATUS.machine_is_on() and (STATUS.is_all_homed() or INFO.NO_HOME_REQUIRED)) def limits_override_test(data): if STATUS.is_homing(): return elif data: self.setEnabled(True) else: self.setEnabled(False) self.setChecked(False) ACTION.TOGGLE_LIMITS_OVERRIDE() def spindle_control_test(e,d): # this can happen if these fwd/rev properties are # changed to up/down in stylesheets - this callback is # still called if self.spindle_up or self.spindle_down: return if self.spindle_fwd: if d in(0,-1): self._safecheck(False) return elif self.spindle_rev: if d in(0,1): self._safecheck(False) return self._safecheck(True) if self.estop: # Estop starts with button down - in estop which # backwards logic for the button... if self.isCheckable(): self._safecheck(True) STATUS.connect('state-estop', lambda w: self._safecheck(True)) STATUS.connect('state-estop-reset', lambda w: self._safecheck(False)) elif self.machine_on or self.abort: #self.setEnabled(False) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('state-estop-reset', lambda w: self.setEnabled(True)) STATUS.connect('state-on', lambda w: self._safecheck(True)) STATUS.connect('state-off', lambda w: self._safecheck(False)) elif True in(self.home, self.unhome, self.home_select, self.unhome_select): #self.setEnabled(False) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on())) STATUS.connect('interp-run', lambda w: self.setEnabled(False)) STATUS.connect('all-homed', lambda w: self._safecheck(True)) STATUS.connect('not-all-homed', lambda w, axis: self._safecheck(False, axis)) elif self.load_dialog: STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on())) STATUS.connect('interp-run', lambda w: self.setEnabled(False)) STATUS.connect('all-homed', lambda w: self._safecheck(True)) elif self.camview_dialog or self.macro_dialog or self.origin_offset_dialog or \ self.tool_offset_dialog or self.tool_chooser_dialog: pass elif self.jog_joint_pos or self.jog_joint_neg or \ self.jog_selected_pos or self.jog_selected_neg: STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on())) STATUS.connect('interp-run', lambda w: self.setEnabled(False)) STATUS.connect('interp-paused', lambda w: self.setEnabled(False)) if self.jog_joint_pos: self.pressed.connect(lambda: self.jog_action(1)) self.released.connect(lambda: self.jog_action(0)) elif self.jog_joint_neg: self.pressed.connect(lambda: self.jog_action(-1)) self.released.connect(lambda: self.jog_action(0)) elif self.jog_selected_pos: self.pressed.connect(lambda: self.jog_selected_action(1)) self.released.connect(lambda: self.jog_selected_action(0)) elif self.jog_selected_neg: self.pressed.connect(lambda: self.jog_selected_action(-1)) self.released.connect(lambda: self.jog_selected_action(0)) # jog button use different action signals so # leave early to avoid the standard 'clicked' signal return elif True in(self.zero_axis, self.zero_g5x,self.zero_g92, self.run, self.zero_zrot, self.run_from_status, self.run_from_slot): STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('interp-idle', lambda w: self.setEnabled(homed_on_test())) STATUS.connect('interp-run', lambda w: self.setEnabled(False)) STATUS.connect('all-homed', lambda w: self.setEnabled(True)) STATUS.connect('not-all-homed', lambda w, data: self.setEnabled(False)) if True in (self.run, self.run_from_status, self.run_from_slot): STATUS.connect('file-loaded', lambda w, f: self.setEnabled(True)) STATUS.connect('interp-paused', lambda w: self.setEnabled(True)) else: STATUS.connect('interp-paused', lambda w: self.setEnabled(False)) if self.run_from_status: STATUS.connect('gcode-line-selected', lambda w, line: self.updateRunFromLine(line)) elif True in(self.pause, self.step): self.setEnabled(False) if self.pause: STATUS.connect('program-pause-changed', lambda w, state: self._safecheck(state)) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('interp-run', lambda w: self.setEnabled(homed_on_test())) STATUS.connect('interp-idle', lambda w: self.setEnabled(False)) elif self.launch_halmeter: pass elif self.launch_status: pass elif self.launch_halshow: pass elif self.launch_halscope: pass elif self.launch_calibration: pass elif self.auto or self.mdi or self.manual: STATUS.connect('interp-run', lambda w: self.setEnabled(False)) STATUS.connect('interp-paused', lambda w: self.setEnabled(False)) STATUS.connect('interp-idle', lambda w: self.setEnabled(True)) if self.auto: STATUS.connect('mode-auto', lambda w: self._safecheck(True)) STATUS.connect('mode-mdi', lambda w: self._safecheck(False)) STATUS.connect('mode-manual', lambda w: self._safecheck(False)) elif self.mdi: STATUS.connect('mode-mdi', lambda w: self._safecheck(True)) STATUS.connect('mode-manual', lambda w: self._safecheck(False)) STATUS.connect('mode-auto', lambda w: self._safecheck(False)) elif self.manual: STATUS.connect('mode-manual', lambda w: self._safecheck(True)) STATUS.connect('mode-mdi', lambda w: self._safecheck(False)) STATUS.connect('mode-auto', lambda w: self._safecheck(False)) elif self.jog_incr: STATUS.connect('metric-mode-changed', lambda w, data: self.incr_action()) STATUS.connect('jogincrement-changed', lambda w, value, text: _checkincrements(value, text)) elif self.feed_over or self.rapid_over or self.spindle_over or self.jog_rate or \ self.max_velocity_over: STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('state-estop-reset', lambda w: self.setEnabled(True)) STATUS.connect('state-on', lambda w: self._safecheck(True)) STATUS.connect('state-off', lambda w: self._safecheck(False)) elif self.view_change: if self.view_type.lower() in('x', 'y', 'y2', 'z', 'z2', 'p'): STATUS.connect('graphics-view-changed', lambda w,v,d: self.view_check(v)) elif self.spindle_fwd or self.spindle_rev or self.spindle_up or self.spindle_down: STATUS.connect('mode-manual', lambda w: self.setEnabled(True)) STATUS.connect('mode-mdi', lambda w: self.setEnabled(False)) STATUS.connect('mode-auto', lambda w: self.setEnabled(False)) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('state-on', lambda w: self.setEnabled(True)) if self.spindle_fwd or self.spindle_rev: STATUS.connect('spindle-control-changed', lambda w, num, e, d, upto: spindle_control_test(e,d)) elif self.spindle_stop: STATUS.connect('mode-manual', lambda w: self.setEnabled(True)) STATUS.connect('mode-mdi', lambda w: self.setEnabled(True)) STATUS.connect('mode-auto', lambda w: self.setEnabled(False)) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('spindle-control-changed', lambda w,num, e, d, upto: self.setEnabled(e and not STATUS.is_auto_mode())) elif self.limits_override: self.setEnabled(False) #STATUS.connect('override-limits-changed', lambda w, data, group: limits_override_test(data)) STATUS.connect('hard-limits-tripped', lambda w, data, group: limits_override_test(data)) elif self.flood: STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('state-on', lambda w: self.setEnabled(True)) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('flood-changed', lambda w, data: self._safecheck(data)) elif self.mist: STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('state-on', lambda w: self.setEnabled(True)) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('mist-changed', lambda w, data: self._safecheck(data)) elif self.block_delete: STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('mode-mdi', lambda w: self.setEnabled(True)) STATUS.connect('mode-manual', lambda w: self.setEnabled(True)) STATUS.connect('mode-auto', lambda w: self.setEnabled(False)) STATUS.connect('block-delete-changed', lambda w, data: self._safecheck(data)) elif self.optional_stop: STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('mode-mdi', lambda w: self.setEnabled(True)) STATUS.connect('mode-manual', lambda w: self.setEnabled(True)) STATUS.connect('mode-auto', lambda w: self.setEnabled(False)) STATUS.connect('optional-stop-changed', lambda w, data: self._safecheck(data)) elif self.mdi_command or self.ini_mdi_command or self.ini_macro_command: STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('interp-idle', lambda w: self.setEnabled(homed_on_test())) STATUS.connect('all-homed', lambda w: self.setEnabled(True)) STATUS.connect('not-all-homed', lambda w, axis: self.setEnabled(False)) if self.ini_mdi_command: self.setMDILabel() elif self.ini_macro_command: self.setMacroLabel() elif self.dro_absolute or self.dro_relative or self.dro_dtg: pass elif True in(self.exit, self.machine_log_dialog): pass elif self.lathe_mirror_x: STATUS.connect('state-off', lambda w: self.setEnabled(False)) STATUS.connect('state-estop', lambda w: self.setEnabled(False)) STATUS.connect('interp-idle', lambda w: self.setEnabled(STATUS.machine_is_on())) STATUS.connect('all-homed', lambda w: self.setEnabled(True)) STATUS.connect('interp-idle', lambda w: self.setEnabled(homed_on_test())) STATUS.connect('interp-run', lambda w: self.setEnabled(False)) elif self._no_action: pass # connect a signal and callback function to the button if self.isCheckable(): self.clicked[bool].connect(self.action) else: self.pressed.connect(self.action) def safecheck(self, state): self._block_signal = True self.setChecked(state) # update indicator if halpin or status doesn't if self._HAL_pin is False and self._ind_status is False: self.indicator_update(state) # if using state labels option update the labels if self._state_text: self.setText(None) self._block_signal = False def view_check(self,data): if data.lower() == self.view_type.lower(): self._safecheck(True) else: self._safecheck(False) ################################### # Here we do the actions ################################### def action(self, state=None): # don't do anything if the signal is blocked if self._block_signal: return if self._no_action: # can be patched by handler self.noActionFunction(self, state) elif self.estop: if self.isCheckable(): if STATUS.estop_is_clear(): ACTION.SET_ESTOP_STATE(STATUS.STATE_ESTOP) else: ACTION.SET_ESTOP_STATE(STATUS.STATE_ESTOP_RESET) else: ACTION.SET_ESTOP_STATE(STATUS.estop_is_clear()) elif self.machine_on: if self.isCheckable(): ACTION.SET_MACHINE_STATE(state) else: LOG.debug('gstat machine is on: {}'.format(STATUS.machine_is_on)) ACTION.SET_MACHINE_STATE(not STATUS.machine_is_on()) elif self.home: if self.isCheckable(): if state: ACTION.SET_MACHINE_HOMING(self.joint) else: if not self.home_no_unhome: ACTION.SET_MACHINE_UNHOMED(self.joint) else: if self.joint == -1: if STATUS.is_all_homed(): if not self.home_no_unhome: ACTION.SET_MACHINE_UNHOMED(-1) else: ACTION.SET_MACHINE_HOMING(-1) elif STATUS.is_joint_homed(self.joint): if not self.home_no_unhome: ACTION.SET_MACHINE_UNHOMED(self.joint) pass else: ACTION.SET_MACHINE_HOMING(self.joint) elif self.unhome: ACTION.SET_MACHINE_UNHOMED(self.joint) elif self.home_select: ACTION.SET_MACHINE_HOMING(STATUS.get_selected_joint()) elif self.unhome_select: ACTION.SET_MACHINE_UNHOMED(STATUS.get_selected_joint()) elif self.run: ACTION.RUN() elif True in(self.run_from_status, self.run_from_slot): ACTION.RUN(line = self._run_from_line_int) elif self.abort: ACTION.ABORT() elif self.pause: ACTION.PAUSE() elif self.step: ACTION.STEP() elif self.load_dialog: STATUS.emit('dialog-request',{'NAME':'LOAD', 'ID':None}) elif self.camview_dialog: STATUS.emit('dialog-request', {'NAME':'CAMVIEW', 'ID':'_%s_'% self.objectName()}) elif self.macro_dialog: STATUS.emit('dialog-request', {'NAME':'MACRO', 'ID':'_%s_'% self.objectName()}) elif self.origin_offset_dialog: STATUS.emit('dialog-request', {'NAME':'ORIGINOFFSET', 'ID':'_%s_'% self.objectName()}) elif self.tool_offset_dialog: STATUS.emit('dialog-request', {'NAME':'TOOLOFFSET', 'ID':'_%s_'% self.objectName()}) elif self.tool_chooser_dialog: STATUS.emit('dialog-request', {'NAME':'TOOLCHOOSER', 'ID':'_%s_'% self.objectName()}) elif self.zero_axis: axis = self.axis if axis == '': # TODO remove this 2.9 workaround in the future LOG.warning("{} should use axis property not joint".format(self.objectName())) j = "XYZABCUVW" try: axis = j[self.joint] except IndexError: LOG.error("can't zero origin for specified joint {}".format(self.joint)) ACTION.SET_AXIS_ORIGIN(axis, 0) STATUS.emit('update-machine-log', 'Zeroed Axis %s' % axis, 'TIME,SUCCESS') elif self.zero_g5x: ACTION.ZERO_G5X_OFFSET(0) elif self.zero_g92: ACTION.ZERO_G92_OFFSET() elif self.zero_zrot: ACTION.ZERO_ROTATIONAL_OFFSET() elif self.launch_halmeter: AUX_PRGM.load_halmeter() elif self.launch_status: AUX_PRGM.load_status() elif self.launch_halshow: AUX_PRGM.load_halshow() elif self.launch_halscope: AUX_PRGM.load_halscope() elif self.launch_calibration: AUX_PRGM.load_calibration() elif self.auto: ACTION.SET_AUTO_MODE() elif self.mdi: ACTION.SET_MDI_MODE() elif self.manual: ACTION.SET_MANUAL_MODE() elif self.jog_incr: self.incr_action() elif self.jog_rate: if self.toggle_float and not self._toggle_state: ACTION.SET_JOG_RATE(self.float_alt) else: ACTION.SET_JOG_RATE(self.float) self._toggle_state -= 1 self._toggle_state = self._toggle_state * -1 elif self.feed_over: if self.toggle_float and not self._toggle_state: ACTION.SET_FEED_RATE(self.float_alt) else: ACTION.SET_FEED_RATE(self.float) self._toggle_state -= 1 self._toggle_state = self._toggle_state * -1 elif self.rapid_over: if self.toggle_float and not self._toggle_state: ACTION.SET_RAPID_RATE(self.float_alt) else: ACTION.SET_RAPID_RATE(self.float) self._toggle_state -= 1 self._toggle_state = self._toggle_state * -1 elif self.max_velocity_over: if self.toggle_float and not self._toggle_state: ACTION.SET_MAX_VELOCITY_RATE(self.float_alt) else: ACTION.SET_MAX_VELOCITY_RATE(self.float) self._toggle_state -= 1 self._toggle_state = self._toggle_state * -1 elif self.spindle_over: if self.toggle_float and not self._toggle_state: ACTION.SET_SPINDLE_RATE(self.float_alt,self.joint) else: ACTION.SET_SPINDLE_RATE(self.float,self.joint) self._toggle_state -= 1 self._toggle_state = self._toggle_state * -1 elif self.view_change: if self.view_type =='reload': STATUS.emit('reload-display') elif self.view_type in('mouse-button-mode', 'pan-lock-mode', 'zoom-lock-mode', 'rotate-lock-mode'): if state: ACTION.SET_GRAPHICS_SCROLL_MODE(('mouse-button-mode', 'pan-lock-mode', 'rotate-lock-mode', 'zoom-lock-mode').index(self.view_type)) else: ACTION.SET_GRAPHICS_SCROLL_MODE(0) else: try: ACTION.SET_GRAPHICS_VIEW(self.view_type) except Exception as e: print(e) pass elif True in (self.spindle_fwd, self.spindle_rev): if self.spindle_fwd: spindir = linuxcnc.SPINDLE_FORWARD else: spindir = linuxcnc.SPINDLE_REVERSE if self.joint == -1: a = 0 b = INFO.AVAILABLE_SPINDLES else: a = self.joint b = self.joint +1 for i in range(a,b): ACTION.SET_SPINDLE_ROTATION(spindir, INFO['DEFAULT_SPINDLE_{}_SPEED'.format(i)],i) elif self.spindle_stop: ACTION.SET_SPINDLE_STOP(self.joint) elif self.spindle_up: if self.joint == -1: a = 0 b = INFO.AVAILABLE_SPINDLES else: a = self.joint b = self.joint +1 for i in range(a,b): if STATUS.is_spindle_on(i): if STATUS.get_spindle_speed(i) >= 0: ACTION.SET_SPINDLE_FASTER(i) else: ACTION.SET_SPINDLE_SLOWER(i) else: ACTION.SET_SPINDLE_ROTATION(linuxcnc.SPINDLE_FORWARD, INFO['DEFAULT_SPINDLE_{}_SPEED'.format(i)],i) elif self.spindle_down: if self.joint ==-1: a = 0 b = INFO.AVAILABLE_SPINDLES else: a = self.joint b = self.joint +1 for i in range(a,b): if STATUS.is_spindle_on(i): if STATUS.get_spindle_speed(i) <= 0: ACTION.SET_SPINDLE_FASTER(i) else: ACTION.SET_SPINDLE_SLOWER(i) else: ACTION.SET_SPINDLE_ROTATION(linuxcnc.SPINDLE_REVERSE, INFO['DEFAULT_SPINDLE_{}_SPEED'.format(i)],i) elif self.limits_override: ACTION.TOGGLE_LIMITS_OVERRIDE() elif self.flood: if self.isCheckable() is False: ACTION.TOGGLE_FLOOD() else: if state: ACTION.SET_FLOOD_ON() else: ACTION.SET_FLOOD_OFF() elif self.mist: if self.isCheckable() is False: ACTION.TOGGLE_MIST() else: if state: ACTION.SET_MIST_ON() else: ACTION.SET_MIST_OFF() elif self.optional_stop: if self.isCheckable() is False: ACTION.TOGGLE_OPTIONAL_STOP() else: if state: ACTION.SET_OPTIONAL_STOP_ON() else: ACTION.SET_OPTIONAL_STOP_OFF() elif self.block_delete: if self.isCheckable() is False: ACTION.TOGGLE_BLOCK_DELETE() else: if state: ACTION.SET_BLOCK_DELETE_ON() else: ACTION.SET_BLOCK_DELETE_OFF() elif self.mdi_command: if self.is_in_mdi_mode_check and not STATUS.is_mdi_mode(): try: self.QTVCP_INSTANCE_.add_status('MDI COMMAND: Not in MDI Mode', WARNING, noLog=False) except: pass return self.command_text = str(self.command_text) LOG.debug("MDI STRING COMMAND: {}".format(self.command_text)) ACTION.CALL_MDI(self.command_text) elif self.ini_mdi_command: if self.is_in_mdi_mode_check and not STATUS.is_mdi_mode(): try: self.QTVCP_INSTANCE_.add_status('INI MDI COMMAND: Not in MDI Mode', WARNING, noLog=False) except: pass return ACTION.RECORD_CURRENT_MODE() # we prefer named INI MDI commands: if not self.ini_mdi_keystring == '' and \ not INFO.get_ini_mdi_command(self.ini_mdi_keystring) is None: cmd = INFO.get_ini_mdi_command(self.ini_mdi_keystring) LOG.debug("INI MDI COMMAND #: {},{}".format(self.ini_mdi_keystring,cmd)) ACTION.CALL_INI_MDI(self.ini_mdi_keystring) # legacy version (nth line) elif not self.ini_mdi_num <0 and \ not INFO.get_ini_mdi_command(self.ini_mdi_num) is None: cmd = INFO.get_ini_mdi_command(self.ini_mdi_num) LOG.debug("INI MDI COMMAND #: {},{}".format(self.ini_mdi_num,cmd)) ACTION.CALL_INI_MDI(self.ini_mdi_num) # set the indicator that the MDI command is running # if the indicator option is turned on and a command is started running if not STATUS.get_current_command() == '': if self._is_mdi_command_finished: self._watch_command_flag = True # nothing moved reset mode else: ACTION.RESTORE_RECORDED_MODE() elif self.ini_macro_command: #print('macro',self.ini_macro_keystring,self.ini_macro_num) if self.is_in_mdi_mode_check and not STATUS.is_mdi_mode(): try: self.QTVCP_INSTANCE_.add_status('INI MACRO COMMAND: Not in MDI Mode', WARNING, noLog=False) except: pass return ACTION.RECORD_CURRENT_MODE() # we prefer named INI MACRO commands: if not self.ini_macro_keystring == '' and \ not INFO.get_ini_macro_command(self.ini_macro_keystring) is None: LOG.debug("INI MACRO COMMAND #: {}".format(self.ini_macro_keystring)) temp = INFO.MACRO_COMMAND_DICT.get(self.ini_macro_keystring).get('cmd') self.runMacro(temp) # legacy version (nth line) elif not self.ini_macro_num <0 and \ not INFO.get_ini_macro_command(self.ini_macro_num) is None: LOG.debug("INI MACRO COMMAND #: {}".format(self.ini_macro_num)) temp = INFO.MACRO_COMMAND_DICT.get(str(self.ini_macro_num)).get('cmd') self.runMacro(temp) # set the indicator that the MDI command is running # if the indicator option is turned on and a command is started running if not STATUS.get_current_command() == '': if self._is_mdi_command_finished: self._watch_command_flag = True # nothing moved reset mode else: ACTION.RESTORE_RECORDED_MODE() elif self.dro_absolute: STATUS.emit('dro-reference-change-request', 0) elif self.dro_relative: STATUS.emit('dro-reference-change-request', 1) elif self.dro_dtg: STATUS.emit('dro-reference-change-request', 2) elif self.exit: self.QTVCP_INSTANCE_.close() elif self.machine_log_dialog: STATUS.emit('dialog-request',{'NAME':'MACHINELOG', 'ID':'_%s_'% self.objectName()}) elif self.lathe_mirror_x: if state: ACTION.SET_LATHE_MIRROR_X() else: ACTION.UNSET_LATHE_MIRROR_X() # default error case else: if state is not None: self.safecheck(state) if not self._python_command: LOG.debug('No action recognised for {}'.format(self.objectName())) # This is check after because action buttons can do an action plus # a python command, or just either one. if self._python_command: if state == None: state = not self._indicator_state self.python_command(state) @QtCore.Slot(int,name='setRunFromLine') def updateRunFromLine(self, data): self._run_from_line_int = int(data) @QtCore.Slot(str,name='setRunFromLine') def updateRunFromLine(self, data): try: self._run_from_line_int = int(data) except ValueError: LOG.error("Value Error setting run from line") # If direction = 0 (button release) and distance is not 0, then we are # doing a jog increment so don't stop jog on release. def jog_selected_action(self, direction): if STATUS.stat.motion_mode == linuxcnc.TRAJ_MODE_FREE: actuator = STATUS.get_selected_joint() else: actuator = STATUS.get_selected_axis() if direction == 0: if actuator in (3,4,5,'A','B','C'): # angualar axis if STATUS.get_jog_increment_angular() != 0: return elif STATUS.get_jog_increment() != 0: return if direction: ACTION.ensure_mode(linuxcnc.MODE_MANUAL) ACTION.DO_JOG(actuator, direction) # If direction = 0 (button release) and distance is not 0, then we are # doing a jog increment so don't stop jog on release. def jog_action(self, direction): if STATUS.stat.motion_mode == linuxcnc.TRAJ_MODE_FREE: actuator = self.joint # joint number less then 0 means convert axis name to joint number if self.joint <0: actuator = INFO.GET_JOG_FROM_NAME[self.axis] else: actuator = self.axis if direction == 0: if actuator in (3,4,5,'A','B','C'): # anglar axis if STATUS.get_jog_increment_angular() != 0: return elif STATUS.get_jog_increment() != 0: return if direction: ACTION.ensure_mode(linuxcnc.MODE_MANUAL) ACTION.DO_JOG(actuator, direction) # We must convert the increments from current 'mode' units to # whatever units the machine is based on. # If the setting is negative don't set it def incr_action(self): if STATUS.is_metric_mode(): # metirc mode G21 if self.jog_incr_mm < 0: return elif self.jog_incr_mm: incr = INFO.convert_metric_to_machine(self.jog_incr_mm) text = '%s mm' % str(self.jog_incr_mm) else: incr = 0 text = 'Continuous' if self.template_label: self._set_alt_text(self.jog_incr_mm) else: if self.jog_incr_imperial < 0: return elif self.jog_incr_imperial: incr = INFO.convert_imperial_to_machine(self.jog_incr_imperial) text = '''%s "''' % str(self.jog_incr_imperial) else: incr = 0 text = 'Continuous' if self.template_label: self._set_text(self.jog_incr_imperial) ACTION.SET_JOG_INCR(incr , text) # set an angular increment if not negative if self.jog_incr_angle < 0: return elif self.jog_incr_angle == 0: incr = 0 text = 'Continuous' else: incr = self.jog_incr_angle text = '''%s deg''' % str(self.jog_incr_angle) ACTION.SET_JOG_INCR_ANGULAR(incr , text) def setText(self,data): #print ('set text:',data, self._designer_running) if self._designer_running: #print('update') self.set_textTemplate(data) super(ActionButton, self).setText(data) def _set_text(self, data): if self._designer_block_signal: return tmpl = lambda s: str(self._textTemplate) % s self.setText(tmpl(data)) def _set_alt_text(self, data): if self._designer_block_signal: return tmpl = lambda s: str(self._alt_textTemplate) % s self.setText(tmpl(data)) # see if the INI specified an optional new label # if so apply it, otherwise skip and use the original text def setMDILabel(self): key = None # we prefer named INI MDI commands if not self.ini_mdi_keystring == '' and \ not INFO.get_ini_mdi_command(self.ini_mdi_keystring) is None: key = self.ini_mdi_keystring # legacy version (nth line) elif not self.ini_mdi_num <0 and \ not INFO.get_ini_mdi_command(self.ini_mdi_num) is None: key = self.ini_mdi_num # change the button label if supplied in the INI try: label = INFO.get_ini_mdi_label(key) label = label.replace(r'\n', '\n') self.setText(label) except: pass # add tool tip of the command try: tooltiplabel = 'INI MDI CMD {}:\n'.format(key) tooltiplabel += INFO.get_ini_mdi_command(key).replace(';', '\n') self.setToolTip(tooltiplabel) except Exception as e: # if the MDI command is missing set a tooltip to say so # otherwise set any optional label msg = 'MDI_COMMAND_{} Not found under [MDI_COMMAND_LIST] in INI file'.format(key) self.setToolTip(msg) # see if the INI specified an optional new label # if so apply it, otherwise skip and use the original text def setMacroLabel(self): key = None # we prefer named INI MDI commands if not self.ini_macro_keystring == '' and \ not INFO.get_ini_macro_command(self.ini_macro_keystring) is None: key = self.ini_macro_keystring # legacy version (nth line) elif not self.ini_macro_num <0 and \ not INFO.get_ini_macro_command(self.ini_macro_num) is None: key = self.ini_macro_num # change the button label if supplied in the INI try: label = INFO.get_ini_macro_label(key) label = label.replace(r'\n', '\n') self.setText(label) except: pass # add tool tip of the command try: tooltiplabel = 'INI MDI CMD {}:\n'.format(key) tooltiplabel += INFO.get_ini_macro_command(key).replace(';', '\n') self.setToolTip(tooltiplabel) except Exception as e: # if the MDI command is missing set a tooltip to say so # otherwise set any optional label msg = 'MDI_COMMAND_{} Not found under [MDI_COMMAND_LIST] in INI file'.format(key) self.setToolTip(msg) # re-definable def noActionFunction(self, widget, state): pass # re-definable def runMacro(self, key): ACTION.RUN_MACRO(key) ######################################################################### # This is how designer can interact with our widget properties. # designer will show the Property properties in the editor # it will use the get set and reset calls to do those actions # # _toggle_properties makes it so we can only select one option ######################################################################## def _toggle_properties(self, picked): data = ('estop', 'machine_on', 'home', 'unhome', 'home_select', 'unhome_select', 'run', 'abort', 'pause', 'step' 'load_dialog', 'jog_joint_pos', 'jog_joint_neg', 'jog_selected_pos', 'jog_selected_neg', 'zero_axis', 'launch_halmeter', 'launch_status', 'launch_halshow', 'auto', 'mdi', 'manual', 'macro_dialog', 'origin_offset_dialog', 'camview_dialog', 'jog_incr', 'feed_over', 'rapid_over', 'spindle_over', 'jog_rate', 'view_change', 'spindle_fwd', 'spindle_rev', 'spindle_stop', 'spindle_up', 'spindle_down', 'limits_override', 'flood', 'mist', 'optional_stop', 'mdi_command', 'ini_mdi_command', 'command_text', 'block_delete', 'dro_absolute', 'dro_relative', 'dro_dtg','max_velocity_over', 'launch_halscope', 'launch_calibration', 'exit', 'machine_log_dialog', 'zero_g5x', 'zero_g92', 'zero_zrot', 'origin_offset_dialog', 'run_from_status', 'run_from_slot', 'tool_chooser_dialog', 'lathe_mirror_x', 'no', 'ini_macro_command') for i in data: if not i == picked: self[i+'_action'] = False # BOOL VARIABLES---------------------- def set_no_action(self, data): self._no_action = data if data: self._toggle_properties('no') def get_no_action(self): return self._no_action def reset_no_action(self): self._no_action = False def set_estop(self, data): self.estop = data if data: self._toggle_properties('estop') def get_estop(self): return self.estop def reset_estop(self): self.estop = False def set_machine_on(self, data): self.machine_on = data if data: self._toggle_properties('machine_on') def get_machine_on(self): return self.machine_on def reset_machine_on(self): self.machine_on = False def set_home(self, data): self.home = data if data: self._toggle_properties('home') def get_home(self): return self.home def reset_home(self): self.home = False def set_unhome(self, data): self.unhome = data if data: self._toggle_properties('unhome') def get_unhome(self): return self.unhome def reset_unhome(self): self.unhome = False def set_home_select(self, data): self.home_select = data if data: self._toggle_properties('home_select') def get_home_select(self): return self.home_select def reset_home_select(self): self.home_select = False def set_unhome_select(self, data): self.unhome_select = data if data: self._toggle_properties('unhome_select') def get_unhome_select(self): return self.unhome_select def reset_unhome_select(self): self.unhome_select = False def set_zero_axis(self, data): self.zero_axis = data if data: self._toggle_properties('zero_axis') def get_zero_axis(self): return self.zero_axis def reset_zero_axis(self): self.zero_axis = False def set_zero_g5x(self, data): self.zero_g5x = data if data: self._toggle_properties('zero_g5x') def get_zero_g5x(self): return self.zero_g5x def reset_zero_g5x(self): self.zero_g5x = False def set_zero_g92(self, data): self.zero_g92 = data if data: self._toggle_properties('zero_g92') def get_zero_g92(self): return self.zero_g92 def reset_zero_g92(self): self.zero_g92 = False def set_zero_zrot(self, data): self.zero_zrot = data if data: self._toggle_properties('zero_zrot') def get_zero_zrot(self): return self.zero_zrot def reset_zero_zrot(self): self.zero_zrot = False def set_load_dialog(self, data): self.load_dialog = data if data: self._toggle_properties('load_dialog') def get_load_dialog(self): return self.load_dialog def reset_load_dialog(self): self.load_dialog = False def set_macro_dialog(self, data): self.macro_dialog = data if data: self._toggle_properties('macro_dialog') def get_macro_dialog(self): return self.macro_dialog def reset_macro_dialog(self): self.macro_dialog = False def set_origin_offset_dialog(self, data): self.origin_offset_dialog = data if data: self._toggle_properties('origin_offset_dialog') def get_origin_offset_dialog(self): return self.origin_offset_dialog def reset_origin_offset_dialog(self): self.origin_offset_dialog = False def set_tool_offset_dialog(self, data): self.tool_offset_dialog = data if data: self._toggle_properties('tool_offset_dialog') def get_tool_offset_dialog(self): return self.tool_offset_dialog def reset_tool_offset_dialog(self): self.tool_offset_dialog = False def set_tool_chooser_dialog(self, data): self.tool_chooser_dialog = data if data: self._toggle_properties('tool_chooser_dialog') def get_tool_chooser_dialog(self): return self.tool_chooser_dialog def reset_tool_chooser_dialog(self): self.tool_chooser_dialog = False def set_camview_dialog(self, data): self.camview_dialog = data if data: self._toggle_properties('camview_dialog') def get_camview_dialog(self): return self.camview_dialog def reset_camview_dialog(self): self.camview_dialog = False def set_jog_joint_pos(self, data): self.jog_joint_pos = data if data: self._toggle_properties('jog_joint_pos') def get_jog_joint_pos(self): return self.jog_joint_pos def reset_jog_joint_pos(self): self.jog_joint_pos = False def set_jog_joint_neg(self, data): self.jog_joint_neg = data if data: self._toggle_properties('jog_joint_neg') def get_jog_joint_neg(self): return self.jog_joint_neg def reset_jog_joint_neg(self): self.jog_joint_neg = False def set_jog_selected_pos(self, data): self.jog_selected_pos = data if data: self._toggle_properties('jog_selected_pos') def get_jog_selected_pos(self): return self.jog_selected_pos def reset_jog_selected_pos(self): self.jog_selected_pos = False def set_jog_selected_neg(self, data): self.jog_selected_neg = data if data: self._toggle_properties('jog_selected_neg') def get_jog_selected_neg(self): return self.jog_selected_neg def reset_jog_selected_neg(self): self.jog_selected_neg = False def set_run(self, data): self.run = data if data: self._toggle_properties('run') def get_run(self): return self.run def reset_run(self): self.run = False def set_run_from_status(self, data): self.run_from_status = data if data: self._toggle_properties('run_from_status') def get_run_from_status(self): return self.run_from_status def reset_run_from_status(self): self.run_from_status = False def set_run_from_slot(self, data): self.run_from_slot = data if data: self._toggle_properties('run_from_slot') def get_run_from_slot(self): return self.run_from_slot def reset_run_from_slot(self): self.run_from_slot = False def set_abort(self, data): self.abort = data if data: self._toggle_properties('abort') def get_abort(self): return self.abort def reset_abort(self): self.abort = False def set_pause(self, data): self.pause = data if data: self._toggle_properties('pause') def get_pause(self): return self.pause def reset_pause(self): self.pause = False def set_step(self, data): self.step = data if data: self._toggle_properties('step') def get_step(self): return self.step def reset_step(self): self.step = False def set_launch_halmeter(self, data): self.launch_halmeter = data if data: self._toggle_properties('launch_halmeter') def get_launch_halmeter(self): return self.launch_halmeter def reset_launch_halmeter(self): self.launch_halmeter = False def set_launch_status(self, data): self.launch_status = data if data: self._toggle_properties('launch_status') def get_launch_status(self): return self.launch_status def reset_launch_status(self): self.launch_status = False def set_launch_halshow(self, data): self.launch_halshow = data if data: self._toggle_properties('launch_halshow') def get_launch_halshow(self): return self.launch_halshow def reset_launch_halshow(self): self.launch_halshow = False def set_launch_halscope(self, data): self.launch_halscope = data if data: self._toggle_properties('launch_halscope') def get_launch_halscope(self): return self.launch_halscope def reset_launch_halscope(self): self.launch_halscope = False def set_launch_calibration(self, data): self.launch_calibration = data if data: self._toggle_properties('launch_calibration') def get_launch_calibration(self): return self.launch_calibration def reset_launch_calibration(self): self.launch_calibration = False def set_auto(self, data): self.auto = data if data: self._toggle_properties('auto') def get_auto(self): return self.auto def reset_auto(self): self.auto = False def set_mdi(self, data): self.mdi = data if data: self._toggle_properties('mdi') def get_mdi(self): return self.mdi def reset_mdi(self): self.mdi = False def set_manual(self, data): self.manual = data if data: self._toggle_properties('manual') def get_manual(self): return self.manual def reset_manual(self): self.manual = False def set_joint(self, data): self.joint = data def get_joint(self): return self.joint def reset_joint(self): self.joint = -1 def set_axis(self, data): if data.upper() in('X','Y','Z','A','B','C','U','V','W'): self.axis = data.upper() def get_axis(self): return self.axis def reset_axis(self): self.axis = 'X' def set_jog_incr(self, data): self.jog_incr = data if data: self._toggle_properties('jog_incr') def get_jog_incr(self): return self.jog_incr def reset_jog_incr(self): self.jog_incr = False def set_jog_rate(self, data): self.jog_rate = data if data: self._toggle_properties('jog_rate') def get_jog_rate(self): return self.jog_rate def reset_jog_rate(self): self.jog_rate = False def set_feed_over(self, data): self.feed_over = data if data: self._toggle_properties('feed_over') def get_feed_over(self): return self.feed_over def reset_feed_over(self): self.feed_over = False def set_rapid_over(self, data): self.rapid_over = data if data: self._toggle_properties('rapid_over') def get_rapid_over(self): return self.rapid_over def reset_rapid_over(self): self.rapid_over = False def set_max_velocity_over(self, data): self.max_velocity_over = data if data: self._toggle_properties('max_velocity_over') def get_max_velocity_over(self): return self.max_velocity_over def reset_max_velocity_over(self): self.max_velocity_over = False def set_spindle_over(self, data): self.spindle_over = data if data: self._toggle_properties('spindle_over') def get_spindle_over(self): return self.spindle_over def reset_spindle_over(self): self.spindle_over = False def set_spindle_fwd(self, data): self.spindle_fwd = data if data: self._toggle_properties('spindle_fwd') def get_spindle_fwd(self): return self.spindle_fwd def reset_spindle_fwd(self): self.spindle_fwd = False def set_spindle_rev(self, data): self.spindle_rev = data if data: self._toggle_properties('spindle_rev') def get_spindle_rev(self): return self.spindle_rev def reset_spindle_rev(self): self.spindle_rev = False def set_spindle_stop(self, data): self.spindle_stop = data if data: self._toggle_properties('spindle_stop') def get_spindle_stop(self): return self.spindle_stop def reset_spindle_stop(self): self.spindle_stop = False def set_spindle_up(self, data): self.spindle_up = data if data: self._toggle_properties('spindle_up') def get_spindle_up(self): return self.spindle_up def reset_spindle_up(self): self.spindle_up = False def set_spindle_down(self, data): self.spindle_down = data if data: self._toggle_properties('spindle_down') def get_spindle_down(self): return self.spindle_down def reset_spindle_down(self): self.spindle_down = False def set_toggle_float(self, data): self.toggle_float = data def get_toggle_float(self): return self.toggle_float def reset_toggle_float(self): self.toggle_float = False def set_limits_override(self, data): self.limits_override = data if data: self._toggle_properties('limits_override') def get_limits_override(self): return self.limits_override def reset_limits_override(self): self.limits_override = False def set_flood(self, data): self.flood = data if data: self._toggle_properties('flood') def get_flood(self): return self.flood def reset_flood(self): self.flood = False def set_mist(self, data): self.mist = data if data: self._toggle_properties('mist') def get_mist(self): return self.mist def reset_mist(self): self.mist = False def set_block_delete(self, data): self.block_delete = data if data: self._toggle_properties('block_delete') def get_block_delete(self): return self.block_delete def reset_block_delete(self): self.block_delete = False def set_optional_stop(self, data): self.optional_stop = data if data: self._toggle_properties('optional_stop') def get_optional_stop(self): return self.optional_stop def reset_optional_stop(self): self.optional_stop = False def set_mdi_command(self, data): self.mdi_command = data if data: self._toggle_properties('mdi_command') def get_mdi_command(self): return self.mdi_command def reset_mdi_command(self): self.mdi_command = False def set_ini_mdi_command(self, data): self.ini_mdi_command = data if data: self._toggle_properties('ini_mdi_command') def get_ini_mdi_command(self): return self.ini_mdi_command def reset_ini_mdi_command(self): self.ini_mdi_command = False def set_mdi_mode_check(self, data): self.is_in_mdi_mode_check = data def get_mdi_mode_check(self): return self.is_in_mdi_mode_check def reset_mdi_mode_check(self): self.is_in_mdi_mode_check = False def set_ini_macro_command(self, data): self.ini_macro_command = data if data: self._toggle_properties('ini_macro_command') def get_ini_macro_command(self): return self.ini_macro_command def reset_ini_macro_command(self): self.ini_macro_command = False def set_dro_absolute(self, data): self.dro_absolute = data if data: self._toggle_properties('dro_absolute') def get_dro_absolute(self): return self.dro_absolute def reset_dro_absolute(self): self.dro_absolute = False def set_dro_relative(self, data): self.dro_relative = data if data: self._toggle_properties('dro_relative') def get_dro_relative(self): return self.dro_relative def reset_dro_relative(self): self.dro_relative = False def set_dro_dtg(self, data): self.dro_dtg = data if data: self._toggle_properties('dro_dtg') def get_dro_dtg(self): return self.dro_dtg def reset_dro_dtg(self): self.dro_dtg = False def set_exit(self, data): self.exit = data if data: self._toggle_properties('exit') def get_exit(self): return self.exit def reset_exit(self): self.exit = False def set_machine_log_dialog(self, data): self.machine_log_dialog = data if data: self._toggle_properties('machine_log_dialog') def get_machine_log_dialog(self): return self.machine_log_dialog def reset_machine_log_dialog(self): self.machine_log_dialog = False def set_lathe_mirror_x(self, data): self.lathe_mirror_x = data if data: self._toggle_properties('lathe_mirror_x') def get_lathe_mirror_x(self): return self.lathe_mirror_x def reset_lathe_mirror_x(self): self.lathe_mirror_x = False def set_home_no_unhome(self, data): self.home_no_unhome = data def get_home_no_unhome(self): return self.home_no_unhome def reset_home_no_unhome(self): self.home_no_unhome = False # NON BOOL VARIABLES------------------ def set_incr_imperial(self, data): self.jog_incr_imperial = data def get_incr_imperial(self): return self.jog_incr_imperial def reset_incr_imperial(self): self.jog_incr_imperial = 0.010 def set_incr_mm(self, data): self.jog_incr_mm = data def get_incr_mm(self): return self.jog_incr_mm def reset_incr_mm(self): self.jog_incr_mm = 0.025 def set_incr_angle(self, data): self.jog_incr_angle = data def get_incr_angle(self): return self.jog_incr_angle def reset_incr_angle(self): self.jog_incr_angle = -1 def set_float(self, data): self.float = data def get_float(self): return self.float def reset_float(self): self.float = 100.0 def set_float_alt(self, data): self.float_alt = data def get_float_alt(self): return self.float_alt def reset_float_alt(self): self.float_alt = 100.0 def set_view_change(self, data): self.view_change = data if data: self._toggle_properties('view_change') def get_view_change(self): return self.view_change def reset_view_change(self): self.view_change = False def set_view_type(self, data): if not data.lower() in('x', 'y', 'y2', 'z', 'z2', 'p', 'clear', 'zoom-in','zoom-out','pan-up','pan-down', 'pan-left','pan-right','rotate-up','rotate-down', 'rotate-cw','rotate-ccw','reload','zoom-lock-mode', 'pan-lock-mode','rotate-lock-mode','scroll-mode'): data = 'p' self.view_type = data def get_view_type(self): return self.view_type def reset_view_type(self): self.view_type = 'p' def set_command_text(self, data): self.command_text = data def get_command_text(self): return self.command_text def reset_command_text(self): self.command_text = '' def set_ini_mdi_num(self, data): self.ini_mdi_num = data def get_ini_mdi_num(self): return self.ini_mdi_num def reset_ini_mdi_num(self): self.ini_mdi_num = -1 def set_ini_mdi_key(self, data): self.ini_mdi_keystring = data def get_ini_mdi_key(self): return self.ini_mdi_keystring def reset_ini_mdi_key(self): self.ini_mdi_keystring = '' def set_ini_macro_key(self, data): self.ini_macro_keystring = data def get_ini_macro_key(self): return self.ini_macro_keystring def reset_ini_macro_key(self): self.ini_macro_keystring = '' def set_ini_macro_num(self, data): self.ini_macro_num = data def get_ini_macro_num(self): return self.ini_macro_num def reset_ini_macro_num(self): self.ini_macro_num = -1 # designer will show these properties in this order: # BOOL no_action = QtCore.Property(bool, get_no_action, set_no_action, reset_no_action) estop_action = QtCore.Property(bool, get_estop, set_estop, reset_estop) machine_on_action = QtCore.Property(bool, get_machine_on, set_machine_on, reset_machine_on) auto_action = QtCore.Property(bool, get_auto, set_auto, reset_auto) mdi_action = QtCore.Property(bool, get_mdi, set_mdi, reset_mdi) manual_action = QtCore.Property(bool, get_manual, set_manual, reset_manual) run_action = QtCore.Property(bool, get_run, set_run, reset_run) run_from_status_action = QtCore.Property(bool, get_run_from_status, set_run_from_status, reset_run_from_status) run_from_slot_action = QtCore.Property(bool, get_run_from_slot, set_run_from_slot, reset_run_from_slot) abort_action = QtCore.Property(bool, get_abort, set_abort, reset_abort) pause_action = QtCore.Property(bool, get_pause, set_pause, reset_pause) step_action = QtCore.Property(bool, get_step, set_step, reset_step) load_dialog_action = QtCore.Property(bool, get_load_dialog, set_load_dialog, reset_load_dialog) camview_dialog_action = QtCore.Property(bool, get_camview_dialog, set_camview_dialog, reset_camview_dialog) origin_offset_dialog_action = QtCore.Property(bool, get_origin_offset_dialog, set_origin_offset_dialog, reset_origin_offset_dialog) tool_offset_dialog_action = QtCore.Property(bool, get_tool_offset_dialog, set_tool_offset_dialog, reset_tool_offset_dialog) tool_chooser_dialog_action = QtCore.Property(bool, get_tool_chooser_dialog, set_tool_chooser_dialog, reset_tool_chooser_dialog) macro_dialog_action = QtCore.Property(bool, get_macro_dialog, set_macro_dialog, reset_macro_dialog) launch_halmeter_action = QtCore.Property(bool, get_launch_halmeter, set_launch_halmeter, reset_launch_halmeter) launch_status_action = QtCore.Property(bool, get_launch_status, set_launch_status, reset_launch_status) launch_halshow_action = QtCore.Property(bool, get_launch_halshow, set_launch_halshow, reset_launch_halshow) launch_halscope_action = QtCore.Property(bool, get_launch_halscope, set_launch_halscope, reset_launch_halscope) launch_calibration_action = QtCore.Property(bool, get_launch_calibration, set_launch_calibration, reset_launch_calibration) home_action = QtCore.Property(bool, get_home, set_home, reset_home) unhome_action = QtCore.Property(bool, get_unhome, set_unhome, reset_unhome) home_select_action = QtCore.Property(bool, get_home_select, set_home_select, reset_home_select) unhome_select_action = QtCore.Property(bool, get_unhome_select, set_unhome_select, reset_unhome_select) zero_axis_action = QtCore.Property(bool, get_zero_axis, set_zero_axis, reset_zero_axis) zero_g5x_action = QtCore.Property(bool, get_zero_g5x, set_zero_g5x, reset_zero_g5x) zero_g92_action = QtCore.Property(bool, get_zero_g92, set_zero_g92, reset_zero_g92) zero_zrot_action = QtCore.Property(bool, get_zero_zrot, set_zero_zrot, reset_zero_zrot) jog_joint_pos_action = QtCore.Property(bool, get_jog_joint_pos, set_jog_joint_pos, reset_jog_joint_pos) jog_joint_neg_action = QtCore.Property(bool, get_jog_joint_neg, set_jog_joint_neg, reset_jog_joint_neg) jog_selected_pos_action = QtCore.Property(bool, get_jog_selected_pos, set_jog_selected_pos, reset_jog_selected_pos) jog_selected_neg_action = QtCore.Property(bool, get_jog_selected_neg, set_jog_selected_neg, reset_jog_selected_neg) jog_incr_action = QtCore.Property(bool, get_jog_incr, set_jog_incr, reset_jog_incr) jog_rate_action = QtCore.Property(bool, get_jog_rate, set_jog_rate, reset_jog_rate) feed_over_action = QtCore.Property(bool, get_feed_over, set_feed_over, reset_feed_over) rapid_over_action = QtCore.Property(bool, get_rapid_over, set_rapid_over, reset_rapid_over) max_velocity_over_action = QtCore.Property(bool, get_max_velocity_over, set_max_velocity_over, reset_max_velocity_over) spindle_over_action = QtCore.Property(bool, get_spindle_over, set_spindle_over, reset_spindle_over) spindle_fwd_action = QtCore.Property(bool, get_spindle_fwd, set_spindle_fwd, reset_spindle_fwd) spindle_rev_action = QtCore.Property(bool, get_spindle_rev, set_spindle_rev, reset_spindle_rev) spindle_stop_action = QtCore.Property(bool, get_spindle_stop, set_spindle_stop, reset_spindle_stop) spindle_up_action = QtCore.Property(bool, get_spindle_up, set_spindle_up, reset_spindle_up) spindle_down_action = QtCore.Property(bool, get_spindle_down, set_spindle_down, reset_spindle_down) view_change_action = QtCore.Property(bool, get_view_change, set_view_change, reset_view_change) limits_override_action = QtCore.Property(bool, get_limits_override, set_limits_override, reset_limits_override) flood_action = QtCore.Property(bool, get_flood, set_flood, reset_flood) mist_action = QtCore.Property(bool, get_mist, set_mist, reset_mist) block_delete_action = QtCore.Property(bool, get_block_delete, set_block_delete, reset_block_delete) optional_stop_action = QtCore.Property(bool, get_optional_stop, set_optional_stop, reset_optional_stop) mdi_command_action = QtCore.Property(bool, get_mdi_command, set_mdi_command, reset_mdi_command) ini_mdi_command_action = QtCore.Property(bool, get_ini_mdi_command, set_ini_mdi_command, reset_ini_mdi_command) mdi_mode_check_action = QtCore.Property(bool, get_mdi_mode_check, set_mdi_mode_check, reset_mdi_mode_check) ini_macro_command_action = QtCore.Property(bool, get_ini_macro_command, set_ini_macro_command, reset_ini_macro_command) dro_absolute_action = QtCore.Property(bool, get_dro_absolute, set_dro_absolute, reset_dro_absolute) dro_relative_action = QtCore.Property(bool, get_dro_relative, set_dro_relative, reset_dro_relative) dro_dtg_action = QtCore.Property(bool, get_dro_dtg, set_dro_dtg, reset_dro_dtg) exit_action = QtCore.Property(bool, get_exit, set_exit, reset_exit) machine_log_dialog_action = QtCore.Property(bool, get_machine_log_dialog, set_machine_log_dialog, reset_machine_log_dialog) lathe_mirror_x_action = QtCore.Property(bool, get_lathe_mirror_x, set_lathe_mirror_x, reset_lathe_mirror_x) home_no_unhome_option = QtCore.Property(bool, get_home_no_unhome, set_home_no_unhome, reset_home_no_unhome) def set_template_label(self, data): self.template_label = data def get_template_label(self): return self.template_label def reset_template_label(self): self.template_label = False template_label_option = QtCore.Property(bool, get_template_label, set_template_label, reset_template_label) # NON BOOL joint_number = QtCore.Property(int, get_joint, set_joint, reset_joint) axis_letter = QtCore.Property(str, get_axis, set_axis, reset_axis) incr_imperial_number = QtCore.Property(float, get_incr_imperial, set_incr_imperial, reset_incr_imperial) incr_mm_number = QtCore.Property(float, get_incr_mm, set_incr_mm, reset_incr_mm) incr_angular_number = QtCore.Property(float, get_incr_angle, set_incr_angle, reset_incr_angle) toggle_float_option = QtCore.Property(bool, get_toggle_float, set_toggle_float, reset_toggle_float) float_num = QtCore.Property(float, get_float, set_float, reset_float) float_alt_num = QtCore.Property(float, get_float_alt, set_float_alt, reset_float_alt) view_type_string = QtCore.Property(str, get_view_type, set_view_type, reset_view_type) command_text_string = QtCore.Property(str, get_command_text, set_command_text, reset_command_text) ini_mdi_number = QtCore.Property(int, get_ini_mdi_num, set_ini_mdi_num, reset_ini_mdi_num) ini_mdi_key = QtCore.Property(str, get_ini_mdi_key, set_ini_mdi_key, reset_ini_mdi_key) ini_macro_number = QtCore.Property(int, get_ini_macro_num, set_ini_macro_num, reset_ini_macro_num) ini_macro_key = QtCore.Property(str, get_ini_macro_key, set_ini_macro_key, reset_ini_macro_key) def set_textTemplate(self, data): self._textTemplate = data def get_textTemplate(self): return self._textTemplate def reset_textTemplate(self): self._textTemplate = '%1.3f in' textTemplate = QtCore.Property(str, get_textTemplate, set_textTemplate, reset_textTemplate) def set_alt_textTemplate(self, data): self._alt_textTemplate = data def get_alt_textTemplate(self): return self._alt_textTemplate def reset_alt_textTemplate(self): self._alt_textTemplate = '%1.2f mm' alt_textTemplate = QtCore.Property(str, get_alt_textTemplate, set_alt_textTemplate, reset_alt_textTemplate) ############################## # required class boiler code # ############################## def __getitem__(self, item): return getattr(self, item) def __setitem__(self, item, value): return setattr(self, item, value) if __name__ == "__main__": import sys from qtpy.QtWidgets import QApplication app = QApplication(sys.argv) widget = ActionButton('Action') # this doesn't get called without qtvcp loading the widget widget.HAL_NAME_ = 'test' widget.PREFS_ = None widget.QTVCP_INSTANCE_ = None widget.draw_indicator = True widget._indicator_state = True widget._hal_init() widget.show() sys.exit(app.exec())