def updateLabelBackground(ctrl, widget): """Helper method to setup background of taurus labels and lcds""" bgRole = widget.bgRole if ctrl.usePalette(): widget.setAutoFillBackground(True) if bgRole in ('', 'none', 'None'): transparentBrush = Qt.QBrush(Qt.Qt.transparent) frameBrush = transparentBrush bgBrush, fgBrush = transparentBrush, Qt.QBrush(Qt.Qt.black) else: frameBrush = Qt.QBrush(Qt.QColor(255, 255, 255, 128)) bgItem, palette = None, QT_DEVICE_STATE_PALETTE if bgRole == 'quality': palette = QT_ATTRIBUTE_QUALITY_PALETTE bgItem = ctrl.quality() elif bgRole == 'state': try: bgItem = ctrl.state() except AttributeError: pass # protect against calls with state not instantiated elif bgRole == 'value': bgItem = ctrl.value() else: # TODO: this is an *experimental* extension of the bgRole API # added in v 4.1.2-alpha. It may change in future versions modelObj = widget.getModelObj() try: bgItem = modelObj.getFragmentObj(bgRole) except: widget.warning('Invalid bgRole "%s"', bgRole) bgBrush, fgBrush = palette.qbrush(bgItem) _updatePaletteColors(widget, bgBrush, fgBrush, frameBrush) else: if bgRole in ('', 'none', 'None'): ss = StyleSheetTemplate.format("rgba(0,0,0,0)", "") else: bgItem, palette = None, QT_DEVICE_STATE_PALETTE if bgRole == 'quality': palette = QT_ATTRIBUTE_QUALITY_PALETTE bgItem = ctrl.quality() elif bgRole == 'state': bgItem = ctrl.state() elif bgRole == 'value': bgItem = ctrl.value() else: # TODO: this is an *experimental* extension of the bgRole API # added in v 4.1.2-alpha. It may change in future versions modelObj = widget.getModelObj() try: bgItem = modelObj.getFragmentObj(bgRole) except: widget.warning('Invalid bgRole "%s"', bgRole) color_ss = palette.qtStyleSheet(bgItem) ss = StyleSheetTemplate.format("rgba(255,255,255,128)", color_ss) widget.setStyleSheet(ss) widget.update() # necessary in pyqt <= 4.4
def update_node(node, key, dct): if hasattr(node, 'CustomForeground'): node.setForeground( 0, Qt.QBrush(Qt.QColor(node.CustomForeground))) if hasattr(node, 'CustomBackground'): node.setBackground( 0, Qt.QBrush(Qt.QColor(node.CustomBackground))) elif hasattr(node, 'StateBackground'): node.setBackground(0, Qt.QBrush(state2color(dct[key]))) if hasattr(node, 'CustomIcon'): node.setIcon(0, Qt.QIcon(node.CustomIcon)) else: if key.count('/') == 2: self.setStateIcon(node, dct and dct[key] or '') return
def qbrush(self, stoq): # print stoq """Returns the brush for the specified state or quality""" name = self._decoder(stoq) f = self._qbrush_cache_fg b = self._qbrush_cache_bg if not f.has_key(name): f[name] = Qt.QBrush(self.qcolor(stoq)[1]) if not b.has_key(name): b[name] = Qt.QBrush(self.qcolor(stoq)[0]) if name == 'None': b[name].setStyle(Qt.Qt.BDiagPattern) return (b[name], f[name])
def build_table(self, values): """ This is a builder. For all the elements in widgets matrix, just set the corresponding cells of the QTableWidget. """ self.trace('In TaurusGrid.build_table(%s)' % values) widgets_matrix = self.build_widgets(values, self.showLabels) rows = len(widgets_matrix) cols = rows and len(widgets_matrix[0]) or 0 table = QtGui.QTableWidget() table.setItemDelegate(Delegate(table)) # This example replaces the blue background of selected cells in tables palette = Qt.QPalette() palette.setBrush(palette.Active, palette.Highlight, Qt.QBrush(Qt.Qt.white)) table.setPalette(palette) table.setRowCount(rows) table.setColumnCount(cols) for row in range(len(widgets_matrix)): for col in range(len(widgets_matrix[row])): table.setCellWidget(row, col, widgets_matrix[row][col]) # table.resizeColumnsToContents() # table.resizeRowsToContents() table.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch) # table.verticalHeader().setResizeMode(QtGui.QHeaderView.Stretch) # table.horizontalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents) table.verticalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents) return table
def __init__(self, plot): Qt.QGraphicsScene.__init__(self, Qt.QGraphicsScene()) gv = self self.plot = plot gv.setBackgroundBrush(Qt.QBrush(Qt.QColor('white'))) self.legend = pg.LegendItem(None, offset=(0, 0)) gv.scene().addItem(self.legend)
def _updateDisplay(self, widget): key = None try: key = self.value() except Exception: pass ledMap = self.LedMap if widget.fgRole == 'quality': ledMap = self.LedQualityMap try: status, color, trouble = ledMap[key] except: status, color, trouble = False, "red", True if self.usePreferedColor(widget): if status: color = widget.onColor else: color = widget.offColor widget.ledStatus = status widget.ledColor = color if trouble: widget.setAutoFillBackground(True) bg_brush = Qt.QBrush(Qt.Qt.BDiagPattern) palette = widget.palette() palette.setBrush(Qt.QPalette.Window, bg_brush) palette.setBrush(Qt.QPalette.Base, bg_brush) widget.setPalette(palette) else: widget.setAutoFillBackground(False)
def setStateBackground(self, child, color): if not isinstance(color, Qt.QColor): if DEVICE_STATE_PALETTE.has(color): qc = Qt.QColor(*DEVICE_STATE_PALETTE.rgb(color)) else: qc = Qt.QColor( color) if not fandango.isSequence(color) else Qt.QColor( *color) child.setBackground(0, Qt.QBrush(qc))
def _setProblemsBackground(self, doIt=True): if doIt: self.setAutoFillBackground(True) bg_brush = Qt.QBrush() bg_brush.setStyle(Qt.Qt.BDiagPattern) palette = self.palette() palette.setBrush(Qt.QPalette.Window, bg_brush) palette.setBrush(Qt.QPalette.Base, bg_brush) else: self.setAutoFillBackground(False)
def get_White_palette(): palette = Qt.QPalette() brush = Qt.QBrush(Qt.QColor(255, 255, 255)) brush.setStyle(Qt.Qt.SolidPattern) palette.setBrush(Qt.QPalette.Active, Qt.QPalette.Base, brush) brush = Qt.QBrush(Qt.QColor(255, 255, 255)) brush.setStyle(Qt.Qt.SolidPattern) palette.setBrush(Qt.QPalette.Active, Qt.QPalette.Window, brush) brush = Qt.QBrush(Qt.QColor(255, 255, 255)) brush.setStyle(Qt.Qt.SolidPattern) palette.setBrush(Qt.QPalette.Inactive, Qt.QPalette.Base, brush) brush = Qt.QBrush(Qt.QColor(255, 255, 255)) brush.setStyle(Qt.Qt.SolidPattern) palette.setBrush(Qt.QPalette.Inactive, Qt.QPalette.Window, brush) brush = Qt.QBrush(Qt.QColor(255, 255, 255)) brush.setStyle(Qt.Qt.SolidPattern) palette.setBrush(Qt.QPalette.Disabled, Qt.QPalette.Base, brush) brush = Qt.QBrush(Qt.QColor(255, 255, 255)) brush.setStyle(Qt.Qt.SolidPattern) palette.setBrush(Qt.QPalette.Disabled, Qt.QPalette.Window, brush) return palette
def _updatePensAndBrushes(self): pon = Qt.QPen(self._ledOnPenColor, self._ledPenWidth, Qt.Qt.SolidLine, Qt.Qt.RoundCap, Qt.Qt.RoundJoin) poff = Qt.QPen(self._ledOffPenColor, self._ledPenWidth, Qt.Qt.SolidLine, Qt.Qt.RoundCap, Qt.Qt.RoundJoin) bon = Qt.QBrush(self._ledOnBgColor, Qt.Qt.SolidPattern) boff = Qt.QBrush(self._ledOffBgColor, Qt.Qt.SolidPattern) pens, brushes = [], [] for nLeds in Q7SegDigit.Leds: nPens = [] nBrushes = [] for onoff in nLeds: if onoff: pen, brush = pon, bon else: pen, brush = poff, boff nPens.append(pen) nBrushes.append(brush) pens.append(nPens) brushes.append(nBrushes) self._pens, self._brushes = pens, brushes self.update()
def updateLabelBackground(ctrl, widget): """Helper method to setup background of taurus labels and lcds""" bgRole = widget.bgRole if ctrl.usePalette(): widget.setAutoFillBackground(True) if bgRole in ('', 'none'): transparentBrush = Qt.QBrush(Qt.Qt.transparent) frameBrush = transparentBrush bgBrush, fgBrush = transparentBrush, Qt.QBrush(Qt.Qt.black) else: frameBrush = Qt.QBrush(Qt.QColor(255, 255, 255, 128)) bgItem, palette = None, QT_DEVICE_STATE_PALETTE if bgRole == 'quality': palette = QT_ATTRIBUTE_QUALITY_PALETTE bgItem = ctrl.quality() elif bgRole == 'state': bgItem = ctrl.state() elif bgRole == 'value': bgItem = ctrl.value() bgBrush, fgBrush = palette.qbrush(bgItem) _updatePaletteColors(widget, bgBrush, fgBrush, frameBrush) else: if bgRole in ('', 'none'): ss = StyleSheetTemplate.format("rgba(0,0,0,0)", "") else: bgItem, palette = None, QT_DEVICE_STATE_PALETTE if bgRole == 'quality': palette = QT_ATTRIBUTE_QUALITY_PALETTE bgItem = ctrl.quality() elif bgRole == 'state': bgItem = ctrl.state() elif bgRole == 'value': bgItem = ctrl.value() color_ss = palette.qtStyleSheet(bgItem) ss = StyleSheetTemplate.format("rgba(255,255,255,128)", color_ss) widget.setStyleSheet(ss) widget.update() # necessary in pyqt <= 4.4
def __init(self): l = Qt.QHBoxLayout() l.setSpacing(10) l.setMargin(5) self.setLayout(l) self._digits = [] for i in xrange(5): d = Q7SegDigit() d.setUseFrame(False) d.setValue(i) l.addWidget(d, 0) self._digits.append(d) self.setAutoFillBackground(True) palette = Qt.QPalette() brush = Qt.QBrush(Qt.Qt.black) palette.setBrush(Qt.QPalette.Active, Qt.QPalette.Window, brush) self.setPalette(palette)
def run(): # Simplify TaurusGui TaurusGui.TAURUS_MENU_ENABLED = False TaurusGui.TOOLS_MENU_ENABLED = False TaurusGui.HELP_MENU_ENABLED = False TaurusGui.FULLSCREEN_TOOLBAR_ENABLED = False TaurusGui.PANELS_MENU_ENABLED = False TaurusGui.APPLETS_TOOLBAR_ENABLED = False TaurusGui.QUICK_ACCESS_TOOLBAR_ENABLED = False app = TaurusApplication(app_name='tpgArchiving') gui = TaurusGui() gui.setWindowTitle('Taurus Archiving Plot') plot = TaurusPlot() #class MyPlot(TaurusPlot): #pass ##def dropEvent(self, event): ##print('In dropEvent(%s)' % str(dir(event))) ##def dragMoveEvent(self,event): ##print('Dragging ...') ##event.acceptProposedAction() ##def dragEnterEvent(self,event): ##print('Entering ...') ##event.acceptProposedAction() #plot = MyPlot() #plot.setAcceptDrops(True) #plot = fandango.qt.Dropable(TaurusPlot)() #plot.setDropLogger(fandango.printf) #plot.setSupportedMimeTypes(fandango.qt.MIMETYPES) plot.setBackgroundBrush(Qt.QColor('white')) axis = DateAxisItem(orientation='bottom') plot_items = plot.getPlotItem() axis.attachToPlotItem(plot_items) # TODO (cleanup menu actions) if plot_items.legend is not None: plot_items.legend.hide() msi = TangoArchivingModelSelectorItem() # hide time stamp selector msi.ui.ts_checkBox.setVisible(False) # hide add single Y model msi._addSelectedAction.setVisible(False) msi.setModel(msi.default_model) # progress bar pb = Qt.QProgressBar() pb.setGeometry(0, 0, 300, 25) def updateProgressBar(stop=True): if stop is True: final = 1 else: final = 0 pb.setRange(0, final) updateProgressBar() ########################################################################### # Update t0 and t1 based on sigXRangeChanged ########################################################################### def onUpdateXViewRange(): x, _ = plot.viewRange() t0, t1 = x t0s = str2localtime(t0) t1s = str2localtime(t1) msi.time_selector.ui.comboBox_begin.setItemText(5, t0s) msi.time_selector.ui.comboBox_end.setItemText(7, t1s) msi.time_selector.ui.comboBox_begin.setItemText(5, t0s) msi.time_selector.ui.comboBox_end.setItemText(7, t1s) msi.time_selector.ui.comboBox_begin.setCurrentIndex(5) msi.time_selector.ui.comboBox_end.setCurrentIndex(7) vb = plot.getPlotItem().getViewBox() vb.sigXRangeChanged.connect(onUpdateXViewRange) ########################################################################### # Legend ########################################################################### gv = Qt.QGraphicsView(Qt.QGraphicsScene()) gv.setBackgroundBrush(Qt.QBrush(Qt.QColor('white'))) l = pg.LegendItem(None, offset=(0, 0)) gv.scene().addItem(l) def updateExternalLegend(): for dataitem in plot_items.listDataItems(): l.removeItem(dataitem.name()) for dataitem in plot_items.listDataItems(): if dataitem.name(): l.addItem(dataitem, dataitem.name()) ########################################################################### # Connect CurvesAppearanceChooser to external legend ########################################################################### from taurus_pyqtgraph.curveproperties import (CurvesAppearanceChooser, CurveAppearanceProperties) def onApply(self): names = self.getSelectedCurveNames() prop = self.getShownProperties() # Update self.curvePropDict for selected properties for n in names: self.curvePropDict[n] = CurveAppearanceProperties.merge( [self.curvePropDict[n], prop], conflict=CurveAppearanceProperties.inConflict_update_a) # emit a (PyQt) signal telling what properties (first argument) need to # be applied to which curves (second argument) # self.curveAppearanceChanged.emit(prop, names) # return both values self.curvePropAdapter.setCurveProperties(self.curvePropDict, names) # Update legend updateExternalLegend() return prop, names # Override CurvesAppearanceChooser.onApply CurvesAppearanceChooser.onApply = onApply ########################################################################### # Helper ########################################################################### def updateAll(legend=True): # Update legend if legend is True: updateExternalLegend() # run plot auto range time.sleep(0.2) # Wait till models are loading plot_items.getViewBox().menu.autoRange() # Stop progress bar updateProgressBar() ########################################################################### # onAddXYModel ########################################################################### def onAddXYModel(models=None): # Update progress bar # updateProgressBar(False) print('onAddXYModel(%s)' % models) if not isSequenceType(models): print('Overriding models ...') models = msi.getSelectedModels() c = msi.cursor() msi.setCursor(Qt.Qt.WaitCursor) current = plot._model_chooser_tool.getModelNames() print('current: %s' % str(current)) models = [m for m in models if m not in current] print('new models: %s' % str(models)) plot.addModels(models) updateAll() msi.setCursor(c) # Connect button msi.modelsAdded.connect(onAddXYModel) #plot.setDropEventCallback(onAddXYModel) ########################################################################### # Override TaurusGui close event ########################################################################### def closeEvent(self, event): try: self.__macroBroker.removeTemporaryPanels() except: pass TaurusMainWindow.closeEvent(self, event) for n, panel in self._TaurusGui__panels.items(): panel.closeEvent(event) panel.widget().closeEvent(event) if not event.isAccepted(): result = Qt.QMessageBox.question( self, 'Closing error', "Panel '%s' cannot be closed. Proceed closing?" % n, Qt.QMessageBox.Yes | Qt.QMessageBox.No) if result == Qt.QMessageBox.Yes: event.accept() else: break for curve in plot_items.listDataItems(): plot.removeItem(curve) l.removeItem(curve.name()) gui.saveSettings() # Override TaurusGui close event TaurusGui.closeEvent = closeEvent ########################################################################### # Create tgarch tool bar ########################################################################### def _onRefresh(): t0, t1 = msi.time_selector.getTimes() # Validate models v = TangoArchivingAttributeNameValidator() query = "{0};t0={1};t1={2}" for curve in plot.getPlotItem().listDataItems(): if isinstance(curve, TaurusPlotDataItem): ymodel = curve.getModel() # tgarch attr if v.getUriGroups(ymodel).get('scheme') != 'tgarch': continue fullname, _, _ = v.getNames(ymodel) bmodel, current_query = fullname.split('?') db = current_query.split(';')[0] q = query.format(db, t0, t1) model = "{0}?{1}".format(bmodel, q) xmodel = "{};ts".format(model) curve.setModel(None) curve.setXModel(None) curve.setModel(model) curve.setXModel(xmodel) updateAll(legend=False) def onRefresh(): # Update progress bar updateProgressBar(False) t1 = threading.Thread(target=_onRefresh) t1.start() tgarchToolBar = gui.addToolBar("TgArch") tgarchToolBar.addAction(Qt.QIcon.fromTheme("view-refresh"), "refresh tgarch curves", onRefresh) ########################################################################### # Create panels ########################################################################### gui.createPanel(plot, 'Plot') gui.createPanel(msi, 'Chooser') gui.createPanel(pb, 'Progress bar') gui.createPanel(gv, 'Legend') # Load configuration gui.loadSettings() gui.show() app.exec_()
def _setBgBrush(self, bgBrush): if isinstance(bgBrush, Qt.QColor): bgBrush = Qt.QBrush(bgBrush, Qt.Qt.SolidPattern) self._bgBrush = bgBrush
class Q7SegDigit(Qt.QWidget): """ A widget representing a single seven segment digit. The style can be configured through the widget properties. For example, a typical LCD would have the following style: - bgColor 170, 170, 127 - ledOnPenColor 30,30,30 - ledOnBgColor 0,0,0 - ledOffPenColor 160, 160, 120 - ledOffbgColor 150, 150, 112 """ Leds = ( (1, 1, 1, 0, 1, 1, 1), # 0 (0, 0, 1, 0, 0, 1, 0), # 1 (1, 0, 1, 1, 1, 0, 1), # 2 (1, 0, 1, 1, 0, 1, 1), # 3 (0, 1, 1, 1, 0, 1, 0), # 4 (1, 1, 0, 1, 0, 1, 1), # 5 (1, 1, 0, 1, 1, 1, 1), # 6 (1, 0, 1, 0, 0, 1, 0), # 7 (1, 1, 1, 1, 1, 1, 1), # 8 (1, 1, 1, 1, 0, 1, 0), # 9 (0, 0, 0, 0, 0, 0, 0), # 10 'nothing' (0, 0, 0, 1, 0, 0, 0), # 11 - (1, 0, 1, 1, 1, 1, 1), # 12 a (0, 0, 0, 1, 1, 1, 0), # 13 n ) # LedGeometries = ( # POLY([P(67, 60), P(283, 60), P(253, 90), P(97, 90), P(67, 60)]), # POLY([P(60, 67), P(90, 97), P(90, 178), P(60, 193), P(60, 67)]), # POLY([P(290, 67), P(260, 97), P(260, 178), P(290, 193), P(290, 67)]), # POLY([P(67, 200), P(97, 185), P(253, 185), P(283, 200), P(253, 215), P(97, 215), P(67, 200)]), # POLY([P(60, 207), P(90, 222), P(90, 303), P(60, 333), P(60, 207)]), # POLY([P(290, 207), P(260, 222), P(260, 303), P(290, 333), P(290, 207)]), # POLY([P(67, 340), P(283, 340), P(253, 310), P(97, 310), P(67, 340)]), # ) LedGeometriesWithFrame300x400 = ( POLY([P(37, 30), P(263, 30), P(233, 60), P(67, 60), P(37, 30)]), POLY([P(30, 37), P(60, 67), P(60, 178), P(30, 193), P(30, 37)]), POLY([P(270, 37), P(240, 67), P(240, 178), P(270, 193), P(270, 37)]), POLY([ P(37, 200), P(67, 185), P(233, 185), P(263, 200), P(233, 215), P(67, 215), P(37, 200) ]), POLY([P(30, 207), P(60, 222), P(60, 333), P(30, 363), P(30, 207)]), POLY([P(270, 207), P(240, 222), P(240, 333), P(270, 363), P(270, 207)]), POLY([P(37, 370), P(263, 370), P(233, 340), P(67, 340), P(37, 370)]), ) LedGeometriesWithoutFrame300x400 = ( POLY([P(7, 0), P(293, 0), P(263, 30), P(37, 30), P(7, 0)]), POLY([P(0, 7), P(30, 37), P(30, 178), P(0, 193), P(0, 7)]), POLY([P(300, 7), P(270, 37), P(270, 178), P(300, 193), P(300, 7)]), POLY([ P(7, 200), P(37, 185), P(263, 185), P(293, 200), P(263, 215), P(37, 215), P(7, 200) ]), POLY([P(0, 207), P(30, 222), P(30, 363), P(0, 393), P(0, 207)]), POLY([P(300, 207), P(270, 222), P(270, 363), P(300, 393), P(300, 207)]), POLY([P(7, 400), P(293, 400), P(263, 370), P(37, 370), P(7, 400)]), ) LedGeometriesWithFrame300x300 = ( POLY([P(37, 30), P(263, 30), P(233, 60), P(67, 60), P(37, 30)]), POLY([P(30, 37), P(60, 67), P(60, 128), P(30, 143), P(30, 37)]), POLY([P(270, 37), P(240, 67), P(240, 128), P(270, 143), P(270, 37)]), POLY([ P(37, 150), P(67, 135), P(233, 135), P(263, 150), P(233, 165), P(67, 165), P(37, 150) ]), POLY([P(30, 157), P(60, 172), P(60, 233), P(30, 263), P(30, 157)]), POLY([P(270, 157), P(240, 172), P(240, 233), P(270, 263), P(270, 157)]), POLY([P(37, 270), P(263, 270), P(233, 240), P(67, 240), P(37, 270)]), ) LedGeometriesWithoutFrame300x300 = ( POLY([P(7, 0), P(293, 0), P(263, 30), P(37, 30), P(7, 0)]), POLY([P(0, 7), P(30, 37), P(30, 128), P(0, 143), P(0, 7)]), POLY([P(300, 7), P(270, 37), P(270, 128), P(300, 143), P(300, 7)]), POLY([ P(7, 150), P(37, 135), P(263, 135), P(293, 150), P(263, 165), P(37, 165), P(7, 150) ]), POLY([P(0, 157), P(30, 172), P(30, 263), P(0, 293), P(0, 157)]), POLY([P(300, 157), P(270, 172), P(270, 263), P(300, 293), P(300, 157)]), POLY([P(7, 300), P(293, 300), P(263, 270), P(37, 270), P(7, 300)]), ) DftLedOnPenColor = Qt.QColor(193, 0, 0, 255) DftLedOnBgColor = Qt.Qt.red DftLedOffPenColor = Qt.QColor(30, 30, 30, 255) DftLedOffBgColor = Qt.QColor(40, 40, 40, 255) DftBgBrush = Qt.QBrush(Qt.Qt.black, Qt.Qt.SolidPattern) DftLedPenWidth = 5 DftValue = '' DftWidth = 300 DftHeight = 300 DftAspectRatio = DftWidth / DftHeight DftUseFrame = True def __init__(self, parent=None, **kwargs): Qt.QWidget.__init__(self, parent) self._setLedPenWidth(Q7SegDigit.DftLedPenWidth) self._setValue(Q7SegDigit.DftValue) self._setLedOnPenColor(Q7SegDigit.DftLedOnPenColor) self._setLedOnBgColor(Q7SegDigit.DftLedOnBgColor) self._setLedOffPenColor(Q7SegDigit.DftLedOffPenColor) self._setLedOffBgColor(Q7SegDigit.DftLedOffBgColor) self._setBgBrush(Q7SegDigit.DftBgBrush) self._setAspectRatio(Q7SegDigit.DftAspectRatio) self._setUseFrame(Q7SegDigit.DftUseFrame) self._updatePensAndBrushes() def minimumSizeHint(self): return Qt.QSize(4, 5.9) def sizeHint(self): # return Qt.QSize(Q7SegDigit.DftWidth, Q7SegDigit.DftHeight) return Qt.QSize(40, 50) def _updatePensAndBrushes(self): pon = Qt.QPen(self._ledOnPenColor, self._ledPenWidth, Qt.Qt.SolidLine, Qt.Qt.RoundCap, Qt.Qt.RoundJoin) poff = Qt.QPen(self._ledOffPenColor, self._ledPenWidth, Qt.Qt.SolidLine, Qt.Qt.RoundCap, Qt.Qt.RoundJoin) bon = Qt.QBrush(self._ledOnBgColor, Qt.Qt.SolidPattern) boff = Qt.QBrush(self._ledOffBgColor, Qt.Qt.SolidPattern) pens, brushes = [], [] for nLeds in Q7SegDigit.Leds: nPens = [] nBrushes = [] for onoff in nLeds: if onoff: pen, brush = pon, bon else: pen, brush = poff, boff nPens.append(pen) nBrushes.append(brush) pens.append(nPens) brushes.append(nBrushes) self._pens, self._brushes = pens, brushes self.update() def __valueStrToLedIndex(self, s): if s is None: s = 10 elif s == '-': s = 11 elif s == 'a': s = 12 elif s == 'n': s = 13 else: try: s = int(s) except: s = 10 return s def paintEvent(self, evt): painter = Qt.QPainter(self) painter.setRenderHint(Qt.QPainter.Antialiasing) painter.setWindow(0, 0, self.DftWidth, self.DftHeight) w, h = float(self.width()), float(self.height()) aspect = w / h if aspect > 0.75: w = h * aspect else: h = w / aspect painter.setViewport(0, 0, w, h) self._paintBorder(painter) self._paintSegment(painter) def _paintBorder(self, painter): if self.getUseFrame(): painter.setPen( Qt.QPen(Qt.Qt.black, 2, Qt.Qt.SolidLine, Qt.Qt.RoundCap, Qt.Qt.RoundJoin)) linGrad = Qt.QLinearGradient(30, 200, 200, 150) linGrad.setColorAt(0, Qt.Qt.darkGray) linGrad.setColorAt(1, Qt.Qt.white) linGrad.setSpread(Qt.QGradient.ReflectSpread) painter.setBrush(linGrad) border2 = Qt.QRectF(0, 0, self.DftWidth, self.DftHeight) painter.drawRoundRect(border2, 10, 10) painter.setBrush(self.getBgBrush()) dist = 20 border1 = Qt.QRectF(dist, dist, self.DftWidth - 2 * dist, self.DftHeight - 2 * dist) painter.drawRoundRect(border1, 5, 5) else: painter.setBrush(self.getBgBrush()) border1 = Qt.QRectF(0, 0, self.DftWidth, self.DftHeight) painter.drawRect(border1) def _paintSegment(self, painter): idx = self.__valueStrToLedIndex(self._value) if self.getUseFrame(): if self.DftHeight == 300: geom = self.LedGeometriesWithFrame300x300 else: geom = self.LedGeometriesWithFrame300x400 else: if self.DftHeight == 300: geom = self.LedGeometriesWithoutFrame300x300 else: geom = self.LedGeometriesWithoutFrame300x400 pens, brushes = self._pens[idx], self._brushes[idx] for i in xrange(7): seg = Qt.QPainterPath() seg.addPolygon(geom[i]) painter.setPen(pens[i]) painter.setBrush(brushes[i]) painter.drawPath(seg) def __str__(self): _, idx = '', self.__valueStrToLedIndex(self._value) leds = self.Leds[idx] # line 0 c = ' ' if leds[0]: c = '_' ret = ' %c \n' % c # line 1 c1, c2, c3 = ' ', ' ', ' ' if leds[1]: c1 = '|' if leds[3]: c2 = '_' if leds[2]: c3 = '|' ret += '%c%c%c\n' % (c1, c2, c3) # line 2 c1, c2, c3 = ' ', ' ', ' ' if leds[4]: c1 = '|' if leds[6]: c2 = '_' if leds[5]: c3 = '|' ret += '%c%c%c' % (c1, c2, c3) return ret def _setValue(self, n): if n is None: self._value = n else: self._value = str(n) def _setLedPenWidth(self, w): self._ledPenWidth = w def _setLedOnPenColor(self, penColor): self._ledOnPenColor = penColor def _setLedOnBgColor(self, bgColor): self._ledOnBgColor = bgColor def _setLedOffPenColor(self, penColor): self._ledOffPenColor = penColor def _setLedOffBgColor(self, bgColor): self._ledOffBgColor = bgColor def _setAspectRatio(self, aspectRatio): self._aspectRatio = aspectRatio def _setBgBrush(self, bgBrush): if isinstance(bgBrush, Qt.QColor): bgBrush = Qt.QBrush(bgBrush, Qt.Qt.SolidPattern) self._bgBrush = bgBrush def _setUseFrame(self, useFrame): self._useFrame = useFrame def getLedOnPenColor(self): return self._ledOnPenColor def setLedOnPenColor(self, penColor): self._setLedOnPenColor(penColor) self._updatePensAndBrushes() def resetLedOnPenColor(self): self.setLenOnPenColor(Q7SegDigit.DftLedOnPenColor) def getLedOnBgColor(self): return self._ledOnBgColor def setLedOnBgColor(self, bgColor): self._setLedOnBgColor(bgColor) self._updatePensAndBrushes() def resetLedOnBgColor(self): self.setLedOnBgColor(Q7SegDigit.DftLedOnBgColor) def getLedOffPenColor(self): return self._ledOffPenColor def setLedOffPenColor(self, penColor): self._setLedOffPenColor(penColor) self._updatePensAndBrushes() def resetLedOffPenColor(self): self.setLenOffPenColor(Q7SegDigit.DftLedOffPenColor) def getLedOffBgColor(self): return self._ledOffBgColor def setLedOffBgColor(self, bgColor): self._setLedOffBgColor(bgColor) self._updatePensAndBrushes() def resetLedOffBgColor(self): self.setLedOffBgColor(Q7SegDigit.DftLedOffBgColor) def getBgBrush(self): return self._bgBrush def setBgBrush(self, bgBrush): self._setBgBrush(bgBrush) self.update() def resetBgBrush(self): self.setBgBrush(Q7SegDigit.DftBgBrush) def setValue(self, n): self._setValue(n) self.update() def getValue(self): return self._value def resetValue(self): self.setValue(Q7SegDigit.DftValue) def setLedPenWidth(self, w): self._setLedPenWidth(w) self._updatePensAndBrushes() def getLedPenWidth(self): return self._ledPenWidth def resetLedPenWidth(self): self.setLedPenWidth(Q7SegDigit.DftLenPenWidth) def setAspectRatio(self, apectRatio): self._setAspectRatio(apectRatio) self.update() def getAspectRatio(self): return self._aspectRatio def resetAspectRatio(self): self.setAspectRatio(Q7SegDigit.DftAspectRatio) def setUseFrame(self, useFrame): self._setUseFrame(useFrame) def getUseFrame(self): return self._useFrame def resetUseFrame(self): self.setUseFrame(Q7SegDigit.DftUseFrame) #: This property holds the led pen color when the led is light ON #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getLedOnPenColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setLedOnPenColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetLedOnPenColor` #: ledOnPenColor = Qt.pyqtProperty("QColor", getLedOnPenColor, setLedOnPenColor, resetLedOnPenColor) #: This property holds the led background color when the led is light ON #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getLedOnBgColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setLedOnBgColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetLedOnBgColor` #: ledOnBgColor = Qt.pyqtProperty("QColor", getLedOnBgColor, setLedOnBgColor, resetLedOnBgColor) #: This property holds the led pen color when the led is light OFF #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getLedOffPenColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setLedOffPenColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetLedOffPenColor` #: ledOffPenColor = Qt.pyqtProperty("QColor", getLedOffPenColor, setLedOffPenColor, resetLedOffPenColor) #: This property holds the led background color when the led is light OFF #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getLedOffBgColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setLedOffBgColor` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetLedOffBgColor` #: ledOffBgColor = Qt.pyqtProperty("QColor", getLedOffBgColor, setLedOffBgColor, resetLedOffBgColor) #: This property holds the background brush #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getBgBrush` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setBgBrush` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetBgBrush` #: bgBrush = Qt.pyqtProperty("QBrush", getBgBrush, setBgBrush, resetBgBrush) #: This property holds the pen width #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getLedPenWidth` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setLedPenWidth` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetLedPenWidth` #: ledPenWidth = Qt.pyqtProperty("int", getLedPenWidth, setLedPenWidth, resetLedPenWidth) #: This property holds wheater of not to draw a frame #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getUseFrame` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setUseFrame` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetUseFrame` #: useFrame = Qt.pyqtProperty("bool", getUseFrame, setUseFrame, resetUseFrame) #: This property holds the widget value #: #: **Access functions:** #: #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.getValue` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.setValue` #: * :meth:`taurus.qt.qtgui.display.Q7SegDigit.resetValue` #: value = Qt.pyqtProperty("QString", getValue, setValue, resetValue)
def set_common_params(self, item, params): if not item: return item._params = params name = params.get('name') if name.lower() == "ignorerepaint": name = "" if not 'extensions' in params: params['extensions'] = {} params.get('extensions')["ignoreRepaint"] = "true" if self.alias: for k, v in self.alias.items(): name = str(name).replace(k, v) # Forcing not-Taurus items to have a name and be able to trigger events setattr(item, '_name', name) if name and not self._delayed: if isinstance(item, TaurusGraphicsItem): #self.debug('TaurusJDrawGraphicsFactory.set_common_params(): %s.setModel(%s)'%(item,name)) item.setModel(name) else: self.debug( 'TaurusJDrawGraphicsFactory.set_common_params(%s): %s is not a TaurusGraphicsItem' % (name, type(item).__name__)) visibilitymapper = params.get('visibilitymapper') if not visibilitymapper is None: mapping_type = visibilitymapper['mapping_type'] mode = visibilitymapper['mode'] default = visibilitymapper['default'] item._default = default item._map = visibilitymapper['map'] visible = params.get('visible') if not visible is None: item.setVisible(visible) extensions = params.get('extensions') if extensions: item._extensions = extensions try: getattr(item, 'setPen') fg = params.get("foreground", (0, 0, 0)) lineWidth = params.get("lineWidth", 1) if lineWidth == 0: pen = Qt.QPen(Qt.Qt.NoPen) else: pen = Qt.QPen(Qt.QColor(fg[0], fg[1], fg[2])) pen.setWidth(lineWidth) pen.setStyle(LINESTYLE_JDW2QT[params.get("lineStyle", 0)]) item.setPen(pen) except AttributeError as ae: pass except Exception as e: self.warning( 'jdraw.set_common_params(%s(%s)).(foreground,width,style) failed!: \n\t%s' % (type(item).__name__, name, traceback.format_exc())) fillStyle = FILLSTYLE_JDW2QT[params.get('fillStyle', 0)] item._fillStyle = fillStyle if hasattr(item, 'brush'): brush = Qt.QBrush() if fillStyle == Qt.Qt.LinearGradientPattern: ox, oy = params.get('origin', (0, 0)) gradient = Qt.QLinearGradient(ox + params.get('gradX1', 0), oy + params.get('gradY1', 0), ox + params.get('gradX2', 0), oy + params.get('gradY2', 0)) c = params.get('gradC1', (0, 0, 0)) gradient.setColorAt(0, Qt.QColor(c[0], c[1], c[2])) c = params.get('gradC2', (255, 255, 255)) gradient.setColorAt(1, Qt.QColor(c[0], c[1], c[2])) gradCyclic = params.get('gradCyclic', False) if gradCyclic: gradient.setSpread(Qt.QGradient.ReflectSpread) brush = Qt.QBrush(gradient) else: brush.setStyle(fillStyle) bg = params.get('background', (255, 255, 255)) brush.setColor(Qt.QColor(bg[0], bg[1], bg[2])) item.setBrush(brush)
pen = Qt.QPen(Qt.QColor(fg[0], fg[1], fg[2])) pen.setWidth(lineWidth) pen.setStyle(LINESTYLE_JDW2QT[params.get("lineStyle", 0)]) item.setPen(pen) except AttributeError, ae: pass except Exception, e: self.warning( 'jdraw.set_common_params(%s(%s)).(foreground,width,style) failed!: \n\t%s' % (type(item).__name__, name, traceback.format_exc())) fillStyle = FILLSTYLE_JDW2QT[params.get('fillStyle', 0)] item._fillStyle = fillStyle if hasattr(item, 'brush'): brush = Qt.QBrush() if fillStyle == Qt.Qt.LinearGradientPattern: ox, oy = params.get('origin', (0, 0)) gradient = Qt.QLinearGradient(ox + params.get('gradX1', 0), oy + params.get('gradY1', 0), ox + params.get('gradX2', 0), oy + params.get('gradY2', 0)) c = params.get('gradC1', (0, 0, 0)) gradient.setColorAt(0, Qt.QColor(c[0], c[1], c[2])) c = params.get('gradC2', (255, 255, 255)) gradient.setColorAt(1, Qt.QColor(c[0], c[1], c[2])) gradCyclic = params.get('gradCyclic', False) if gradCyclic: gradient.setSpread(Qt.QGradient.ReflectSpread)
def __init__(self, parent=None): Qt.QWidget.__init__(self, parent) self.loadUi() self._controllers = [] # construct the layout for controllers container self.ctrlLayout = Qt.QHBoxLayout(self.controllersContainer) self.ctrlLayout.setContentsMargins(5, 0, 5, 0) self.ctrlLayout.setSpacing(1) # implement scroll bars for the controllers container self.scrollArea = Qt.QScrollArea(self) self.scrollArea.setWidget(self.controllersContainer) self.scrollArea.setVerticalScrollBarPolicy(Qt.Qt.ScrollBarAlwaysOff) self.scrollArea.setWidgetResizable(True) self.cpointsGroupBox.layout().insertWidget(0, self.scrollArea) # initialize data cpoints = 2 self.x = numpy.arange(256, dtype='double') self.y = numpy.zeros(256, dtype='double') self.xp = numpy.linspace(self.x[0], self.x[-1], cpoints) self.corrp = numpy.zeros(cpoints) self.yp = numpy.interp(self.xp, self.x, self.y) self.corr = numpy.zeros(self.x.size) # markers self.markerPos = self.xp[0] self.marker1 = Qwt5.QwtPlotMarker() self.marker1.setSymbol( Qwt5.QwtSymbol(Qwt5.QwtSymbol.Rect, Qt.QBrush(Qt.Qt.NoBrush), Qt.QPen(Qt.Qt.green), Qt.QSize(8, 8))) self.marker1.attach(self.plot1) self.marker2 = Qwt5.QwtPlotMarker() self.marker2.setSymbol( Qwt5.QwtSymbol(Qwt5.QwtSymbol.Rect, Qt.QBrush(Qt.Qt.NoBrush), Qt.QPen(Qt.Qt.green), Qt.QSize(8, 8))) self.marker2.attach(self.plot2) # cpointsPickers self._cpointMovingIndex = None self._cpointsPicker1 = Qwt5.QwtPicker(self.plot1.canvas()) self._cpointsPicker1.setSelectionFlags(Qwt5.QwtPicker.PointSelection) self._cpointsPicker2 = Qwt5.QwtPicker(self.plot2.canvas()) self._cpointsPicker2.setSelectionFlags(Qwt5.QwtPicker.PointSelection) self._cpointsPicker1.widgetMousePressEvent = self.plot1MousePressEvent self._cpointsPicker1.widgetMouseReleaseEvent = self.plot1MouseReleaseEvent self._cpointsPicker2.widgetMousePressEvent = self.plot2MousePressEvent self._cpointsPicker2.widgetMouseReleaseEvent = self.plot2MouseReleaseEvent self._cpointsPicker1.widgetMouseDoubleClickEvent = self.plot1MouseDoubleClickEvent self._cpointsPicker2.widgetMouseDoubleClickEvent = self.plot2MouseDoubleClickEvent self._populatePlots() self.resetCorrection() self._selectedController = self._controllers[0] self._addCPointsDialog = AddCPointsDialog(self) # Launch low-priority initializations (to speed up load time) # Qt.QTimer.singleShot(0, <method>) # connections self.addCPointsBT.clicked.connect(self._addCPointsDialog.show) self._addCPointsDialog.editBT.clicked.connect( self.showEditCPointsDialog) self._addCPointsDialog.cleanBT.clicked.connect(self.resetCorrection) self._addCPointsDialog.addSingleCPointBT.clicked.connect( self.onAddSingleCPointBT) self._addCPointsDialog.addRegEspCPointsBT.clicked.connect( self.onAddRegEspCPointsBT)
def fillTaurusConfig(self, item, configdict): ''' Fills the non-top nodes of the dictionary recursively. :param item: (Qt.QStandardItem) parent item :param configdict: (dict) a configuration dictionary. See :class:`BaseConfigurableClass` ''' if not BaseConfigurableClass.isTaurusConfig(configdict): return # fill the registered keys registeredkeys = configdict.get('__orderedConfigNames__', []) valuesdict = configdict.get('__itemConfigurations__', {}) for k in registeredkeys: value = valuesdict[k] child = Qt.QStandardItem(k) if BaseConfigurableClass.isTaurusConfig(value): child.setEditable(False) item.appendRow(child) txt = Qt.from_qvariant(item.data(Qt.Qt.UserRole), str) path = Qt.QVariant(txt + ";__itemConfigurations__;" + k) child.setData(path, Qt.Qt.UserRole) # recursive call to fill all nodes self.fillTaurusConfig(child, value) else: typeV = Qt.QStandardItem(repr(type(value))) valueV = Qt.QStandardItem(repr(value)) typeV.setForeground(Qt.QBrush(Qt.QColor('gray'))) child.setForeground(Qt.QBrush(Qt.QColor('gray'))) item.appendRow([child, typeV, valueV]) txt = Qt.from_qvariant(item.data(Qt.Qt.UserRole), str) path = Qt.QVariant(txt + ";__itemConfigurations__;" + k) child.setEditable(False) typeV.setEditable(False) child.setData(path, Qt.Qt.UserRole) typeV.setData(path, Qt.Qt.UserRole) valueV.setData(path, Qt.Qt.UserRole) customkeys = [k for k in configdict if k not in ( '__orderedConfigNames__', '__itemConfigurations__', 'ConfigVersion', '__pickable__')] if len(customkeys) > 0: custom = Qt.QStandardItem('[custom]') item.appendRow(custom) custom.setEditable(False) # custom.setSelectable(False) custom.setBackground(Qt.QBrush(Qt.QColor('gray'))) for k in customkeys: value = configdict[k] child = Qt.QStandardItem(str(k)) # item.appendRow(child) if BaseConfigurableClass.isTaurusConfig(value): child.setEditable(False) item.appendRow(child) txt = Qt.from_qvariant(item.data(Qt.Qt.UserRole), str) path = Qt.QVariant(txt + ";" + k) child.setData(path, Qt.Qt.UserRole) # recursive call to fill all nodes self.fillTaurusConfig(child, value) else: typeV = Qt.QStandardItem(repr(type(value))) valueV = Qt.QStandardItem(repr(value)) typeV.setForeground(Qt.QBrush(Qt.QColor('gray'))) child.setForeground(Qt.QBrush(Qt.QColor('gray'))) item.appendRow([child, typeV, valueV]) txt = Qt.from_qvariant(item.data(Qt.Qt.UserRole), str) path = Qt.QVariant(txt + ";" + k) child.setData(path, Qt.Qt.UserRole) child.setEditable(False) typeV.setEditable(False) typeV.setData(path, Qt.Qt.UserRole) valueV.setData(path, Qt.Qt.UserRole)