<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">
import sys
import importlib
from qtvcp.core import Path, Qhal, Action
PATH = Path()
QHAL = Qhal()
ACTION = Action()

# get reference to original handler file so we can subclass it
sys.path.insert(0, PATH.SCREENDIR)
module = "{}.{}_handler".format(PATH.BASEPATH,PATH.BASEPATH)
mod = importlib.import_module(module, PATH.SCREENDIR)
sys.path.remove(PATH.SCREENDIR)
HandlerClass = mod.HandlerClass

# return our subclassed handler object
def get_handlers(halcomp, widgets, paths):
    return [UserHandlerClass(halcomp, widgets, paths)]

class UserHandlerClass(HandlerClass):
    print('Custom subclassed handler loaded\n')

    def init_pins(self):
        super().init_pins()
        self.FEED_RATE_ENABLE = 0
        self.SPINDLE_RATE_ENABLE = 0
        self.ANGULAR_JOG_RATE_ENABLE = 0
        self.JOG_RATE_ENABLE = 0
        self.RAPID_RATE_ENABLE = 0
        # generate the pins to connect analog inputs for sliders
        pin = QHAL.newpin("feed.feed-override.analog-enable", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_enable_changed(s,"FEED_RATE"))
        pin = QHAL.newpin("spindle.spindle-override.analog-enable", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_enable_changed(s,"SPINDLE_RATE"))
        pin = QHAL.newpin("jog.jog-velocity.analog-enable", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_enable_changed(s,"JOG_RATE"))
        pin = QHAL.newpin("jog.angular-jog-velocity.analog-enable", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_enable_changed(s,"ANGULAR_JOG_RATE"))
        pin = QHAL.newpin("rapid.rapid-override.analog-enable", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_enable_changed(s,"RAPID_RATE"))

        pin = QHAL.newpin("feed.feed-override.direct-value", QHAL.HAL_FLOAT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_value_changed(s,"FEED_RATE"))
        pin = QHAL.newpin("spindle.spindle-override.direct-value", QHAL.HAL_FLOAT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_value_changed(s,"SPINDLE_RATE"))
        pin = QHAL.newpin("jog.jog-velocity.direct-value", QHAL.HAL_FLOAT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_value_changed(s,"JOG_RATE"))
        pin = QHAL.newpin("jog.angular-jog-velocity.direct-value", QHAL.HAL_FLOAT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_value_changed(s,"ANGULAR_JOG_RATE"))
        pin = QHAL.newpin("rapid.rapid-override.direct-value", QHAL.HAL_FLOAT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self._on_analog_value_changed(s,"RAPID_RATE"))

        # make a pin to set jog rate range
        pin = QHAL.newpin("jog.turtle-jog", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self.toggle_jog_range(s))

        # call keyboard jogging function on HAL pin change
        # kb_jog(state, joint number, direction, fast = False, linear = True)

        # jog pins X axis
        pin = QHAL.newpin("jog.axis.jog-x-plus", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self.kb_jog(s, 0, 1, fast = False, linear = True))

        pin = QHAL.newpin("jog.axis.jog-x-minus", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self.kb_jog(s, 0, -1, fast = False, linear = True))

        # jog pins A axis
        pin = QHAL.newpin("jog.axis.jog-a-plus", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self.kb_jog(s, 3, 1, fast = False, linear = False))

        pin = QHAL.newpin("jog.axis.jog-a-minus", QHAL.HAL_BIT, QHAL.HAL_IN)
        pin.value_changed.connect(lambda s: self.kb_jog(s, 3, -1, fast = False, linear = False))

    def toggle_jog_range(self, state):
        if not self.w.btn_jog_l_slow.isChecked() == state:
            self.w.btn_jog_l_slow.setChecked(state)
            self.setSlider(self.w.slider_jog_linear, self.w.btn_jog_l_slow, state)
        if not self.w.btn_jog_a_slow.isChecked() == state:
            self.w.btn_jog_a_slow.setChecked(state)
            self.setSlider(self.w.slider_jog_angular, self.w.btn_jog_a_slow, state)

    def setSlider(self, slider, button, state):
        current = slider.value()
        max = slider.maximum()
        if state:
            button.setText("SLOW")
            slider.setMaximum(max / self.slow_jog_factor)
            slider.setValue(current / self.slow_jog_factor)
            slider.setPageStep(10)
        else:
            button.setText("FAST")
            slider.setMaximum(max * self.slow_jog_factor)
            slider.setValue(current * self.slow_jog_factor)
            slider.setPageStep(100)

    def _on_analog_enable_changed(self, state, command):
        self['{}_ENABLE'.format(command)] = state

    def _on_analog_value_changed(self, value, command):
        #print(value,command,self['{}_ENABLE'.format(command)])
        if self['{}_ENABLE'.format(command)]:
            if command == 'JOG_RATE':
                self.w.slider_jog_linear.setValue(self.w.slider_jog_linear.maximum()*value)
            elif command == 'ANGULAR_JOG_RATE':
                self.w.slider_jog_angular.setValue(self.w.slider_jog_angular.maximum()*value)
            elif command == "FEED_RATE":
                self.w.slider_feed_ovr.setValue(self.w.slider_jog_linear.maximum()*value)
            elif command == "SPINDLE_RATE":
                self.w.slider_spindle_ovr.setValue(self.w.slider_jog_linear.maximum()*value)
            elif command == "RAPID_RATE":
                self.w.slider_rapid_ovr.setValue(self.w.slider_jog_linear.maximum()*value)
            else:
                ACTION['SET_{}'.format(command)](value*100)

</pre></body></html>