Import LinuxCNC source tree

lib/python/qtvcp/widgets/led_widget.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+# qtvcp
+#
+# Copyright (c) 2017  Chris Morley <chrisinnanaimo@hotmail.com>
+#
+# 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.
+#
+#################################################################################
+
+from qtpy.QtCore import Property, Slot, Qt, QTimer, QSize
+from qtpy.QtGui import QColor, QPainter, QBrush, QRadialGradient
+from qtpy.QtWidgets import QWidget
+from qtvcp.widgets.widget_baseclass import _HalWidgetBase, hal
+from qtvcp import logger
+
+# Instantiate the libraries with global reference
+# LOG is for running code logging
+LOG = logger.getLogger(__name__)
+
+# Set the log level for this module
+# LOG.setLevel(logger.INFO) # One of DEBUG, INFO, WARNING, ERROR, CRITICAL
+
+
+class LED(QWidget, _HalWidgetBase):
+    def __init__(self, parent=None):
+        super(LED, self).__init__(parent)
+        self._diamX = 0
+        self._diamY = 0
+        self._diameter = 15
+        self._color = QColor("red")
+        self._off_color = QColor("black")
+        self._gradient = True
+        self._on_gradient_color = Qt.white
+        self._off_gradient_color = Qt.white
+        self._border_color = QColor("black")
+        self._alignment = Qt.AlignCenter
+        self.state = False
+        self.flash = False
+        self._state = False
+        self._flashing = False
+        self._flashRate = 200
+
+        self._timer = QTimer()
+        self._timer.timeout.connect(self.toggleState)
+
+        self.setDiameter(self._diameter)
+        self.setGradient(self._gradient)        
+
+        self._halpin_option = True
+
+    def _hal_init(self):
+        if (self._halpin_option):
+
+            if self._pin_name_ == '':
+                pname = self.HAL_NAME_
+            else:
+                pname = self._pin_name_
+
+            self.hal_pin = self.HAL_GCOMP_.newpin(pname, hal.HAL_BIT, hal.HAL_IN)
+            self.hal_pin.value_changed.connect(lambda s: self.change_state(s))
+
+    @Slot(bool)
+    def change_state(self, data):
+        self.state = data
+        if data and self.flash:
+            self.setFlashing(True)
+        elif data and not self.flash:
+            self.setState(True)
+        else:
+            self.setFlashing(False)
+            self.setState(False)
+
+    def paintEvent(self, event):
+        painter = QPainter()
+        x = 0
+        y = 0
+        if self._alignment & Qt.AlignLeft:
+            x = 0
+        elif self._alignment & Qt.AlignRight:
+            x = self.width() - self._diameter
+        elif self._alignment & Qt.AlignHCenter:
+            x = (self.width() - self._diameter) // 2
+        elif self._alignment & Qt.AlignJustify:
+            x = 0
+
+        if self._alignment & Qt.AlignTop:
+            y = 0
+        elif self._alignment & Qt.AlignBottom:
+            y = self.height() - self._diameter
+        elif self._alignment & Qt.AlignVCenter:
+            y = (self.height() - self._diameter) // 2
+
+        if self._gradient:
+            gradient = QRadialGradient(x + self._diameter / 2, y + self._diameter / 2,
+                                       self._diameter * 0.4, self._diameter * 0.4, self._diameter * 0.4)
+
+
+            if self._state:
+                gradient.setColorAt(0, self._on_gradient_color)
+                gradient.setColorAt(1, self._color)
+            else:
+                gradient.setColorAt(0, self._off_gradient_color)
+                gradient.setColorAt(1, self._off_color)
+
+            brush = QBrush(gradient)
+        else:
+            brush = QBrush(self._color if self._state else self._off_color)
+
+        painter.begin(self)
+        painter.setPen(self._border_color)
+        painter.setRenderHint(QPainter.Antialiasing, True)
+        painter.setBrush(brush)
+        painter.drawEllipse(x, y, self._diameter - 1, self._diameter - 1)
+        painter.end()
+
+    def minimumSizeHint(self):
+        return QSize(self._diameter, self._diameter)
+
+    def sizeHint(self):
+        return QSize(self._diameter, self._diameter)
+
+    def getDiameter(self):
+        return self._diameter
+
+    def set_halpin_option(self, value):
+        self._halpin_option = value
+    def get_halpin_option(self):
+        return self._halpin_option
+    def reset_halpin_option(self):
+        self._halpin_option = True
+
+    @Slot(int)
+    def setDiameter(self, value):
+        self._diameter = value
+        self.update()
+
+    def getColor(self):
+        return self._color
+
+    @Slot(QColor)
+    def setColor(self, value):
+        self._color = value
+        self.update()
+
+    def getOffColor(self):
+        return self._off_color
+
+    @Slot(QColor)
+    def setOffColor(self, value):
+        self._off_color = value
+        self.update()
+
+    def getOnGradientColor(self):
+        return self._on_gradient_color
+    @Slot(QColor)
+    def setOnGradientColor(self, value):
+        self._on_gradient_color = value
+        self.update()
+    def resetOnGradientColor(self, value):
+        self._on_gradient_color = Qt.white
+        self.update()
+
+    def getOffGradientColor(self):
+        return self._off_gradient_color
+    @Slot(QColor)
+    def setOffGradientColor(self, value):
+        self._off_gradient_color = value
+        self.update()
+    def resetOffGradientColor(self, value):
+        self._off_gradient_color = Qt.white
+        self.update()
+
+    def getGradient(self):
+        return self._gradient            
+
+    @Slot(bool)
+    def setGradient(self, value):
+        self._gradient = value
+        self.update()            
+
+    def resetGradient(self):
+        self._gradient = True        
+
+    def getBorderColor(self):
+        return self._border_color
+
+    @Slot(QColor)
+    def setBorderColor(self, value):
+        self._border_color = value
+        self.update()
+
+    def getAlignment(self):
+        return self._alignment
+
+    @Slot(object)
+    def setAlignment(self, value):
+        self._alignment = value
+        self.update()
+
+    def resetAlignment(self):
+        self._alignment = Qt.AlignCenter
+
+    @Slot(bool)
+    @Slot(int)
+    def setState(self, value):
+        self.state = self._state = value
+        self.update()
+
+    def getState(self):
+        return self.state
+
+    def resetState(self):
+        self.state = self._state = False
+
+    @Slot()
+    def toggleState(self):
+        self._state = not self._state
+        self.update()
+
+    def isFlashing(self):
+        return self._flashing
+
+    @Slot(bool)
+    def setFlashing(self, value):
+        self._flashing = value
+        if self._flashRate > 0 and value:
+            if self._timer.isActive():
+                return
+            self._timer.start(self._flashRate)
+        else:
+            self._timer.stop()
+            # make sure when flashing stops led ends up at state
+            self._state = self.state
+        self.update()
+
+    # flash when state on
+    def setFlashState(self, value):
+        self.flash = value
+        self.update()
+
+    def getFlashState(self):
+        return self.flash
+
+    def getFlashRate(self):
+        return self._flashRate
+
+    @Slot(int)
+    def setFlashRate(self, value):
+        self._flashRate = value
+        self.update()
+
+    def set_pin_name(self, value):
+        self._pin_name_ = value
+    def get_pin_name(self):
+        return self._pin_name_
+    def reset_pin_name(self):
+        self._pin_name_ = ''
+
+    pin_name = Property(str, get_pin_name, set_pin_name, reset_pin_name)
+    halpin_option = Property(bool, get_halpin_option, set_halpin_option, reset_halpin_option)
+    diameter = Property(int, getDiameter, setDiameter)
+    gradient = Property(bool, getGradient, setGradient, resetGradient)
+    color = Property(QColor, getColor, setColor)
+    off_color = Property(QColor, getOffColor, setOffColor)
+    off_gradient_color = Property(QColor, getOffGradientColor, setOffGradientColor, resetOffGradientColor)
+    on_gradient_color = Property(QColor, getOnGradientColor, setOnGradientColor, resetOnGradientColor)
+    border_color = Property(QColor, getBorderColor, setBorderColor)
+    alignment = Property(int, getAlignment, setAlignment, resetAlignment)
+    currentstate = Property(bool, getState, setState, resetState)
+    flashing = Property(bool, getFlashState, setFlashState)
+    flashRate = Property(int, getFlashRate, setFlashRate)
+
+if __name__ == "__main__":
+
+    import sys
+    from qtpy.QtWidgets import QApplication
+    app = QApplication(sys.argv)
+    led = LED()
+    led.show()
+
+    # Flash always when method called test
+    #led.setFlashing(True)
+    # this shouldn't matter
+    #led.setState(False)
+
+    # Flash only when state on test
+    led.setFlashState(True)
+    # only flash when this is true
+    led.change_state(False)
+
+    sys.exit(app.exec())