def runPyDM(ui=None, disp_args=[], pfmon=None, mcro=None): app = PyDMApplication(ui_file=ui, command_line_args=disp_args, perfmon=pfmon, macros=mcro) app.exec_()
def qapp(pytestconfig): global application if application: pass else: application = PyDMApplication() if pytestconfig.getoption('--dark'): import qdarkstyle application.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5()) return application
def main(): _parse_arguments() app = PyDMApplication(command_line_args=sys.argv, hide_nav_bar=True, hide_menu_bar=True, hide_status_bar=True, use_main_window=False) pydm_chartsdipslay = PyDMChartingDisplay() pydm_chartsdipslay.setMinimumSize(1600, 800) pydm_chartsdipslay.show() sys.exit(app.exec_())
def qapp(pytestconfig): global application if application: pass else: application = PyDMApplication(use_main_window=False) if pytestconfig.getoption('--dark'): import qdarkstyle application.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5()) else: typhon.use_stylesheet() return application
def do_search(self): # For each widget inside the results frame, lets destroy them for widget in self.frmLT_result.findChildren(QWidget): widget.setParent(None) widget.deleteLater() for widget in self.frmBO_result.findChildren(QWidget): widget.setParent(None) widget.deleteLater() for widget in self.frmSR_result.findChildren(QWidget): widget.setParent(None) widget.deleteLater() for widget in self.frmDCL_result.findChildren(QWidget): widget.setParent(None) widget.deleteLater() # Grab the filter text filter_text = self.txt_filter.text() # For every entry in the dataset... for entry in self.BBB_PS_list: # Check if they match our filter if filter_text.upper() not in entry.upper(): continue # Create macros list dict_macro_BBB = { "PS_CON": entry, "PYTHON": "python" if platform.system() == "Windows" else "python3" } for i in range(1, len(self.BBB_PS_list[entry]) + 1): dict_macro_BBB["PS{}".format(i)] = self.BBB_PS_list[entry][i - 1] # Create a PyDMEmbeddedDisplay for this entry disp = PyDMEmbeddedDisplay(parent=self) PyDMApplication.instance().close_widget_connections(disp) disp.macros = json.dumps(dict_macro_BBB) disp.filename = 'PS_Controller.ui' disp.setMinimumWidth(700) disp.setMinimumHeight(40) disp.setMaximumHeight(100) # Add the Embedded Display to the Results Layout if "DCL" in entry: self.resultsDCL_layout.addWidget(disp) elif "SI" in entry: self.resultsSR_layout.addWidget(disp) elif "BO" in entry: self.resultsBO_layout.addWidget(disp) elif ("TB" in entry) or ("TS" in entry): self.resultsLT_layout.addWidget(disp) PyDMApplication.instance().establish_widget_connections(disp)
def main(): parser = argparse.ArgumentParser(description="Python Display Manager") parser.add_argument( 'displayfile', help= 'A PyDM file to display. Can be either a Qt .ui file, or a Python file.', nargs='?', default=None) parser.add_argument( '--perfmon', action='store_true', help= 'Enable performance monitoring, and print CPU usage to the terminal.') parser.add_argument('--hide-nav-bar', action='store_true', help='Start PyDM with the navigation bar hidden.') parser.add_argument('--hide-menu-bar', action='store_true', help='Start PyDM with the menu bar hidden.') parser.add_argument('--hide-status-bar', action='store_true', help='Start PyDM with the status bar hidden.') parser.add_argument('--read-only', action='store_true', help='Start PyDM in a Read-Only mode.') parser.add_argument( '-m', '--macro', help= 'Specify macro replacements to use, in JSON object format. Reminder: JSON requires double quotes for strings, so you should wrap this whole argument in single quotes. Example: -m \'{"sector": "LI25", "facility": "LCLS"}' ) parser.add_argument( 'display_args', help= 'Arguments to be passed to the PyDM client application (which is a QApplication subclass).', nargs=argparse.REMAINDER) pydm_args = parser.parse_args() macros = None if pydm_args.macro is not None: try: macros = json.loads(pydm_args.macro) except ValueError: raise ValueError("Could not parse macro argument as JSON.") app = PyDMApplication(ui_file=pydm_args.displayfile, command_line_args=pydm_args.display_args, perfmon=pydm_args.perfmon, hide_nav_bar=pydm_args.hide_nav_bar, hide_menu_bar=pydm_args.hide_menu_bar, hide_status_bar=pydm_args.hide_status_bar, read_only=pydm_args.read_only, macros=macros) sys.exit(app.exec_())
def __init__(self, parent=None, args=[], macros=None): super(TableDisplay, self).__init__(parent=parent, args=args, macros=macros) table_batch = len(devices) * 8 # if len(devices) * 8 < 30 else 30 horizontal_header_labels = [ 'Channel Name', 'Device Name', 'Device Alpha', 'Temperature', 'Temperature Raw' ] self.tdc = MBTempTableDataController( self.table, devices=devices, table_batch=table_batch, horizontal_header_labels=horizontal_header_labels) self.tfFilter.editingFinished.connect( lambda: self.filter(self.tfFilter.text())) self.btnNavLeft.clicked.connect(lambda: self.update_navbar(False)) self.btnNavLeft.setIcon(IconFont().icon('arrow-left')) self.btnNavRight.clicked.connect(lambda: self.update_navbar(True)) self.btnNavRight.setIcon(IconFont().icon('arrow-right')) PyDMApplication.instance().hide_nav_bar = True
def qapp(pytestconfig): global application application = QtWidgets.QApplication.instance() if application is None: application = PyDMApplication(use_main_window=False) typhos.use_stylesheet(pytestconfig.getoption('--dark')) return application
def qapp(pytestconfig): global application if application: pass else: application = PyDMApplication(use_main_window=False) typhon.use_stylesheet(pytestconfig.getoption('--dark')) return application
def __init__(self, parent=None, args=None, macros=None): super(TableDisplay, self).__init__(parent=parent, args=args, macros=macros) table_batch = 0 for device in DEVICES: if not device.enable: continue for channel in device.channels: if not channel.enable: continue table_batch += 1 horizontal_header_labels = [ "Channel Name", "Device Name", "Device Alpha", "Temperature", ] # "Temperature Raw",] self.tdc = MBTempTableDataController( self.table, devices=DEVICES, table_batch=table_batch, horizontal_header_labels=horizontal_header_labels, ) self.tfFilter.editingFinished.connect( lambda: self.filter(self.tfFilter.text())) self.TempMax.valueChanged.connect( lambda: self.tdc.update_TempMaxMin(Maximum=self.TempMax.value())) self.TempMin.valueChanged.connect( lambda: self.tdc.update_TempMaxMin(Minimum=self.TempMin.value())) self.btnNavLeft.clicked.connect(lambda: self.update_navbar(False)) self.btnNavLeft.setIcon(IconFont().icon("arrow-left")) self.btnNavRight.clicked.connect(lambda: self.update_navbar(True)) self.btnNavRight.setIcon(IconFont().icon("arrow-right")) PyDMApplication.instance().hide_nav_bar = True
return True except: return False def errorMessage(self, message): self.showDialog("---Attention---", message) ''' ____________________________________________________________________________________________________________________________________ Functions not used ''' if __name__ == "__main__": import sys app = PyDMApplication(use_main_window=False) Ui_MainWindow_Ocean = QtWidgets.QMainWindow() ui = PressureSystem() ui.setupUi(Ui_MainWindow_Ocean) ui.setFlowControl(oceanPV="SOL3", motorPV="SOL:galil:test:A", LS="XDS:LS") Ui_MainWindow_Ocean.show() app.establish_widget_connections(widget=Ui_MainWindow_Ocean) sys.exit(app.exec_()) ''' self.ui.lblAcquiring.linkActivated.connect(self.pri1) self.ui.lblAcquiring.linkHovered.connect(self.pri1) #self.ui.lblAcquiring.channel. self.ui.lblProgress.value_changed(0) self.ui.cmbAcquisition.send_value_signal.connect(self.pri1) '''
#!/usr/bin/env python import sys import argparse from pydm import PyDMApplication if __name__ == "__main__": parser = argparse.ArgumentParser(description="Python Display Manager") parser.add_argument( 'displayfile', help= 'A PyDM file to display. Can be either a Qt .ui file, or a Python file.', nargs='?', default=None) parser.add_argument( 'display_args', help= 'Arguments to be passed to the PyDM client application (which is a QApplication subclass).', nargs=argparse.REMAINDER) pydm_args = parser.parse_args() app = PyDMApplication(ui_file=pydm_args.displayfile, command_line_args=pydm_args.display_args) sys.exit(app.exec_())
nargs='?', default=None) parser.add_argument( '--perfmon', action='store_true', help= 'Enable performance monitoring, and print CPU usage to the terminal.') parser.add_argument( '-m', '--macro', help= 'Specify macro replacements to use, in JSON object format. Reminder: JSON requires double quotes for strings, so you should wrap this whole argument in single quotes. Example: -m \'{"sector": "LI25", "facility": "LCLS"}' ) parser.add_argument( 'display_args', help= 'Arguments to be passed to the PyDM client application (which is a QApplication subclass).', nargs=argparse.REMAINDER) pydm_args = parser.parse_args() macros = None if pydm_args.macro is not None: try: macros = json.loads(pydm_args.macro) except ValueError: raise ValueError("Could not parse macro argument as JSON.") app = PyDMApplication(ui_file=pydm_args.displayfile, command_line_args=pydm_args.display_args, perfmon=pydm_args.perfmon, macros=macros) sys.exit(app.exec_())
#!/usr/bin/python3 import sys from PyQt5 import uic from PyQt5.QtWidgets import QMainWindow from pydm import PyDMApplication app = PyDMApplication() window = uic.loadUi('pvsim.ui') window.show() sys.exit(app.exec_())
def __init__(self, parent=None, macros=None, args=None, average="Gamma Detectors"): super().__init__(parent=parent, args=args, macros=macros, ui_filename=OVERVIEW_UI) self.setWindowTitle("Overview of Time Bases") self.alpha = [0, 0, 0, 0, 0] # Initially doesn't show none graph self.average = average self.groups = ["{:0>2d}".format(sec) for sec in range(1, 21)] self.x = numpy.arange(len(self.groups)) self.width = 0.185 self.dict_pvs_tb = {} self.dict_macro_gamma = {} self.gamma_1 = [0] * 20 self.gamma_2 = [0] * 20 self.gamma_3 = [0] * 20 self.gamma_4 = [0] * 20 self.gamma_5 = [0] * 20 self.fig, self.ax = plt.subplots(figsize=(12, 8)) # self.fig.canvas.set_window_title("Overview") # self.fig.subplots_adjust(left=0.05, bottom=0.08, right=0.95, top=0.95) # Adjustments of graphics plt.subplots_adjust(left=0.1) # self.fig.text(0.03, 0.25, "Control of\n Graphic", ha="center") self.ani = FuncAnimation(fig=self.fig, func=self.animate, interval=10000) self.animate() self.checkButtons_setting() plt.show() if self.average == "Gamma Detectors": # If user chose 'Counting - Overview' for PV in range(1, 21): for s_sec in range(2): self.dict_pvs_tb["valueTB{}{}".format( PV, counters[s_sec] )] = "ca://SI-{:0>2d}{}:CO-Counter:TimeBase-SP".format( PV, counters[s_sec]) if PV != 20: self.dict_pvs_tb["valueTB{}M1".format( PV )] = "ca://SI-{:0>2d}M1:CO-Counter:TimeBase-SP".format(PV + 1) else: self.dict_pvs_tb["valueTB{}M1".format( PV)] = "ca://SI-01M1:CO-Counter:TimeBase-SP" for location in range(1, 21): for s_sec in range(len(Det_Location)): self.dict_macro_gamma["DET{}".format( s_sec)] = "SI-{:0>2d}{}:CO-Gamma".format( location, Det_Location[s_sec]) if s_sec < 3: self.dict_macro_gamma["TimeBase{}".format( s_sec)] = "{}".format( self.dict_pvs_tb["valueTB{}{}".format( location, counters[s_sec])]) a = PyDMChannel( address="ca://SI-{:0>2d}{}:CO-Gamma:Count-Mon".format( location, Det_Location[s_sec]), value_slot=partial(self.plot, location=location, det=s_sec), ) # Connect to Counting PVs a.connect() self.disp = PyDMEmbeddedDisplay( parent=self) # Creates the window of Time Bases PyDMApplication.instance().close_widget_connections(self.disp) self.disp.macros = json.dumps(self.dict_macro_gamma) self.disp.filename = LAYOUT_OVERVIEW_UI self.disp.setMinimumWidth(300) self.disp.setMinimumHeight(140) self.verticalLayout.addWidget(self.disp) PyDMApplication.instance().establish_widget_connections( self.disp) else: # If user chose some Average for location in range(1, 21): for s_sec in range(len(Det_Location)): a = PyDMChannel( address="ca://SI-{:0>2d}{}:CO-Gamma:{}-Mon".format( location, Det_Location[s_sec], self.average), value_slot=partial(self.plot, location=location, det=s_sec), ) # Connect to Averages PVs a.connect()
def invertedScale(self): """ Whether or not the motor scale is inverted. Returns ------- bool """ return self._inverted_scale @invertedScale.setter def invertedScale(self, inverted): """ Whether or not the motor scale is inverted. Parameters ---------- flipped : bool """ if self._inverted_scale != inverted: self._inverted_scale = inverted self.build_layout(self._orientation, self._flipped, inverted) if __name__ == '__main__': app = PyDMApplication() #widget = QMotor(init_channel='SOL8:m1') widget = QMotor(init_channel='A') app.establish_widget_connections(widget=widget) sys.exit(app.exec_())
def acceptedChanges_pvname(self): ''' PV names edition ''' try: self.getting_pvname() self.showDialog(title = 'Please Wait', text = 'Please Wait While E-MA Configures E-MA Application') self.ui_ocean.setFlowControl(oceanPV = self.pvname_ocean, motorPV = self.pvname_motorGearBox, LS = self.pvname_lakeshore) except OSError as err: self.showDialog(title = 'Error on PV names edition', text = err) self.Ui_MainWindow_editPVnames.close() def rejectedChanges_pvname(self): self.Ui_MainWindow_editPVnames.close() def showDialog(self,title = None, text = None): """Show a simple message dialog""" msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText(text) msg.setWindowTitle(title) msg.exec_() if __name__ == '__main__': pass app = PyDMApplication(use_main_window=False) app.load_external_tools() ui_Dioptas = MainController() emapp = EmaApp() sys.excepthook = excepthook sys.exit(app.exec_()) QtWidgets.QApplication.closeAllWindows()
#!/usr/local/lcls/package/python/current/bin/python import sys, os from pydm.PyQt import QtCore, QtGui from display_ui import Ui_MainWindow from pydm import PyDMApplication class DisplayWindow(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QMainWindow.__init__(self, parent) self.ui = Ui_MainWindow() self.ui.setupUi(self) if __name__ == "__main__": app = PyDMApplication(sys.argv) window = DisplayWindow() window.show() app.start_connections() sys.exit(app.exec_())
def openPyDM(self): app_pydm = PyDMApplication(sys.argv) app_pydm.new_window("lineEditTestPyDM.ui")
def stop(self): """Stop.""" self.update_timer.stop() def set_update_interval(self, interval): """Set timer update interval.""" self.update_timer.stop() self.model.update_interval = interval self.update_timer.start(self.model.update_interval) def channels(self): """Used by PyDmApplication to set the model channel.""" if isinstance(self.model, PyDMBarGraphModel): return self.model.channels() return [PyDMChannel()] if __name__ == "__main__": import sys from pydm import PyDMApplication app = PyDMApplication(None, sys.argv) w = BarGraphWidget() w.set_scale(100) w.set_brush("b") pv = "fac-lnls455-linux-SI-13C4:DI-DCCT:BbBCurrent-Mon" w.model.channel = pv w.show() sys.exit(app.exec_())