def __init__(self, *args):
self.main = args[0]
super(LoginWindow, self).__init__()
loadUi(getcwd() + '/ui/login.ui', self)
self.setWindowIcon(QIcon(getcwd() + "/images/icon.ico"))
self.setModal(True)
self.show()
def __init__(self, *args):
super(MainWindow, self).__init__(*args)
loadUi('ui.ui', self)
self.setStatusTip('ready')
# контейнер для нашего изображения
self.labels = []
def __init__(self, parent):
super().__init__(parent)
uic.loadUi("ui/load_mail_model_window.ui", self)
# Load model names from database.
for model in api.mail.get_models():
self.model_list.addItem(model['name'])
def __init__(self, controller):
QtWidgets.QWidget.__init__(self)
self.ctrlr = controller
self.edit_use_method_names = {}
self.create_dialog = None
self.edit_dialog = None
# currently visible partition bar
self.active_bar = None
uic.loadUi(os.path.join(_uidir, 'stepPartMan.ui'), self)
self.part_advanced_warning_hbox.setVisible(False)
self.part_advanced_bootloader_frame.setVisible(False)
self.partition_tree_model = PartitionModel(
self.ctrlr, self.partition_list_treeview)
self.partition_list_treeview.setModel(self.partition_tree_model)
self.partition_list_treeview.selectionModel().selectionChanged.connect(
self.on_treeviewSelectionChanged)
self.partition_button_new_label.clicked[bool].connect(
self.on_new_table_clicked)
self.partition_button_new.clicked[bool].connect(self.on_new_clicked)
self.partition_button_edit.clicked[bool].connect(self.on_edit_clicked)
self.partition_button_delete.clicked[bool].connect(
self.on_delete_clicked)
self.undo_everything.clicked[bool].connect(self.on_undo_clicked)
def __init__(self, settings, tribler_version):
self._logger = logging.getLogger(self.__class__.__name__)
QMainWindow.__init__(self)
self.request_mgr = None
self.cpu_plot = None
self.memory_plot = None
self.initialized_cpu_plot = False
self.initialized_memory_plot = False
self.cpu_plot_timer = None
self.memory_plot_timer = None
self.tribler_version = tribler_version
self.profiler_enabled = False
self.toggling_profiler = False
uic.loadUi(get_ui_file_path('debugwindow.ui'), self)
self.setWindowTitle("Tribler debug pane")
self.window().dump_memory_core_button.clicked.connect(lambda: self.on_memory_dump_button_clicked(True))
self.window().dump_memory_gui_button.clicked.connect(lambda: self.on_memory_dump_button_clicked(False))
self.window().toggle_profiler_button.clicked.connect(self.on_toggle_profiler_button_clicked)
self.window().debug_tab_widget.setCurrentIndex(0)
self.window().ipv8_tab_widget.setCurrentIndex(0)
self.window().tunnel_tab_widget.setCurrentIndex(0)
self.window().system_tab_widget.setCurrentIndex(0)
self.window().debug_tab_widget.currentChanged.connect(self.tab_changed)
self.window().ipv8_tab_widget.currentChanged.connect(self.ipv8_tab_changed)
self.window().tunnel_tab_widget.currentChanged.connect(self.tunnel_tab_changed)
self.window().events_tree_widget.itemClicked.connect(self.on_event_clicked)
self.window().system_tab_widget.currentChanged.connect(self.system_tab_changed)
self.load_general_tab()
self.window().open_files_tree_widget.header().setSectionResizeMode(0, QHeaderView.Stretch)
# Enable/disable tabs, based on settings
self.window().debug_tab_widget.setTabEnabled(2, settings and settings['trustchain']['enabled'])
self.window().debug_tab_widget.setTabEnabled(3, settings and settings['ipv8']['enabled'])
self.window().system_tab_widget.setTabEnabled(3, settings and settings['resource_monitor']['enabled'])
self.window().system_tab_widget.setTabEnabled(4, settings and settings['resource_monitor']['enabled'])
# Refresh logs
self.window().log_refresh_button.clicked.connect(lambda: self.load_logs_tab())
self.window().log_tab_widget.currentChanged.connect(lambda index: self.load_logs_tab())
# IPv8 statistics enabled?
self.ipv8_statistics_enabled = settings['ipv8']['statistics']
# Libtorrent tab
self.init_libtorrent_tab()
# Position to center
frame_geometry = self.frameGeometry()
screen = QDesktopWidget().screenNumber(QDesktopWidget().cursor().pos())
center_point = QDesktopWidget().screenGeometry(screen).center()
frame_geometry.moveCenter(center_point)
self.move(frame_geometry.topLeft())
# Refresh timer
self.refresh_timer = None
def showMessageSlot(self):
dialog = QDialog(core.mainWindow())
uic.loadUi(os.path.join(DATA_FILES_PATH, 'ui/Exception.ui'), dialog)
dialog.textBrowser.setText(text)
dialog.exec_()
def __init__(self, parent=None):
QMainWindow.__init__(self)
self.parent = parent
uic.loadUi('src/GUI/testmain.ui', self)
self.resize(100, 100)
def __init__(self,logger, logincallback, parent=None):
self.logincallback = logincallback #We call this on successful login
self.logger = logger
super(LoginWindow,self).__init__(parent = parent)
mydir = os.path.dirname(__file__)
uic.loadUi(os.path.join(mydir,"resources/login.ui"),self)
logofile = os.path.join(mydir,"resources/logo.png")
self.logo.setPixmap(QPixmap(logofile))
self.setWindowIcon(QIcon(logofile))
#The default device text
self.connect_devicename.setText("laptop")
self.create_devicename.setText("laptop")
#The ConnectorDB database url
self.connect_server.setText(connectordb.CONNECTORDB_URL)
#Set the login button callback
self.login_button.clicked.connect(self.login)
self.create_button.clicked.connect(self.create)
# Set the connectordb version
self.version.setText(version)
# Only enable the "create" tab if the executable is found
if files.getConnectorDB() is None:
logging.info("Couldn't find ConnectorDB executable. Not showing create tab.")
self.tabWidget.removeTab(1)
def _initUic(self):
p = os.path.split(__file__)[0] + "/"
if p == "/":
p = "." + p
uic.loadUi(p + "ui/multiStepProgressDialog.ui", self)
self.buttonBox.button(QDialogButtonBox.Ok).hide()
self.failedLabel.hide()
def __init__(self, console_font):
super(SettingsDialog, self ).__init__()
self.console_font = console_font
uic.loadUi(os.path.join(os.path.dirname(__file__), 'Ui_SettingsDialog.ui'), self)
QMetaObject.connectSlotsByName(self)
self.update_label()
self.btn_fontEdit.clicked.connect(self.on_fontEdit_clicked)
def _createWidget(self):
widget = QWidget(self)
uic.loadUi(os.path.join(os.path.dirname(__file__), 'Preview.ui'), widget)
widget.webView.page().setLinkDelegationPolicy(QWebPage.DelegateAllLinks)
widget.webView.page().linkClicked.connect(self._onLinkClicked) # Disconnected.
# Fix preview palette. See https://github.com/bjones1/enki/issues/34
webViewPalette = widget.webView.palette()
webViewPalette.setColor(QPalette.Inactive, QPalette.HighlightedText,
webViewPalette.color(QPalette.Text))
widget.webView.setPalette(webViewPalette)
widget.webView.page().mainFrame().titleChanged.connect(
self._updateTitle) # Disconnected.
widget.cbEnableJavascript.clicked.connect(
self._onJavaScriptEnabledCheckbox) # Disconnected.
widget.webView.installEventFilter(self)
self.setWidget(widget)
self.setFocusProxy(widget.webView)
widget.tbSave.clicked.connect(self.onPreviewSave) # Disconnected.
# Add an attribute to ``widget`` denoting the splitter location.
# This value will be overwritten when the user changes splitter location.
widget.splitterErrorStateSize = (199, 50)
widget.splitterNormStateSize = (1, 0)
widget.splitterNormState = True
widget.splitter.setSizes(widget.splitterNormStateSize)
widget.splitter.splitterMoved.connect(self.on_splitterMoved) # Disconnected.
return widget
def __init__(self, work_id, date_from, date_to):
super(RestOneWork, self).__init__()
loadUi(getcwd() + '/ui/report_rest_one_work.ui', self)
self.setWindowIcon(QIcon(getcwd() + "/images/icon.ico"))
self.start_settings()
self.set_sql_info(work_id, date_from, date_to)
def __init__(self, parent, title, main_text, buttons, show_input=False):
DialogContainer.__init__(self, parent)
uic.loadUi(get_ui_file_path('buttonsdialog.ui'), self.dialog_widget)
self.dialog_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.dialog_widget.dialog_title_label.setText(title)
self.dialog_widget.dialog_main_text_label.setText(main_text)
self.dialog_widget.dialog_main_text_label.adjustSize()
if not show_input:
self.dialog_widget.dialog_input.setHidden(True)
else:
self.dialog_widget.dialog_input.returnPressed.connect(lambda: self.button_clicked.emit(0))
hspacer_left = QSpacerItem(1, 1, QSizePolicy.Expanding, QSizePolicy.Fixed)
self.dialog_widget.dialog_button_container.layout().addSpacerItem(hspacer_left)
self.buttons = []
for index in range(len(buttons)):
self.create_button(index, *buttons[index])
hspacer_right = QSpacerItem(1, 1, QSizePolicy.Expanding, QSizePolicy.Fixed)
self.dialog_widget.dialog_button_container.layout().addSpacerItem(hspacer_right)
self.window().escape_pressed.connect(self.close_dialog)
self.on_main_window_resize()
def __init__(self, title='Boogi', *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
loadUi('gui/main_window.ui', self)
QShortcut(QKeySequence("Esc"), self, self.toggleArticleView)
self.hideArticleView()
self.setWindowTitle(title)
def __init__(self, main, id=None):
super(ChangeCard, self).__init__()
loadUi(getcwd() + '/ui/staff_card.ui', self)
self.setWindowIcon(QIcon(getcwd() + "/images/icon.ico"))
self.main = main
self.id = id
self.set_start_settings()
def __init__(self, parent):
super().__init__()
self.__network = parent.ntw
parent.NeuronParametersButton.setEnabled(False)
self.__parent = parent
uic.loadUi('GUI/forms/neuron_parameters_form.ui', self)
self.init_ui()
# load parameters from network
self.ElectrodeSensitivitySlider.setValue(self.__network.get_parameter(ID_SENSITIVITY)*10)
self.ThresholdSpinBox.setValue(self.__network.get_parameter(ID_THRESHOLD))
self.PotentialRelaxTimeSpinBox.setValue(self.__network.get_parameter(ID_POTENTIAL_RELAX_TIME))
self.StrengthMinSpinBox.setValue(self.__network.get_parameter(ID_STRENGTH_MIN))
self.StrengthMaxSpinBox.setValue(self.__network.get_parameter(ID_STRENGTH_MAX))
self.StrengthRelaxTimeSpinBox.setValue(self.__network.get_parameter(ID_STRENGTH_RELAX_TIME))
self.MaxResourceSpinBox.setValue(self.__network.get_parameter(ID_RESOURCE_MAX_BY_STRENGTH))
self.ResistanceSpinBox.setValue(self.__network.get_parameter(ID_RESISTANCE))
self.SynMaxSpinBox.setValue(self.__network.get_parameter(ID_SYN_VALUE_MAX))
self.SynMinSpinBox.setValue(self.__network.get_parameter(ID_SYN_VALUE_MIN))
self.SynRelaxTimeSpinBox.setValue(self.__network.get_parameter(ID_CONNECTION_RELAX_TIME))
# self.StimCurrentSpinBox.setValue(self.__network.get_parameter(INJECTOR_ID_RESOURCE_MAX)) # TODO: not working yet
for i in range(11):
self.__parameters_set.append(None)
self.show()
def __init__(self, task_records, *args, **kwargs):
super().__init__(*args, **kwargs)
ui_dir_path = os.path.dirname(__file__)
ui_file_path = os.path.join(ui_dir_path, 'task_record.ui')
uic.loadUi(ui_file_path, self)
self.task_records = task_records
self.set_table_widget()
def __init__(self, resource, size):
# Load UI
super(TARWindow, self).__init__()
uic.loadUi(GUI_FOLDER + 'tarCreation.ui', self)
self.resource = cv2.imread(resource)
self.h, self.w = self.resource.shape[:2]
self.tileSize = size
# We'll need a temporal folder
self.tmp_dir = tempfile.mkdtemp()
# In order to get the tiles we'll define the size
self.resourceView.setIconSize(QSize(size, size))
# Defining labels
self.comprLabel.setText('Compression:')
c = self.getTiles(self.resource, self.h, self.w, self.tileSize)
self.columns, self.rows = c
self.refreshdir(self.columns, self.rows, self.tileSize)
# Radio Buttons in a group
self.comprGroup = QButtonGroup()
self.comprGroup.addButton(self.tarRadio)
self.comprGroup.addButton(self.targzRadio)
self.comprGroup.addButton(self.tarbz2Radio)
self.comprGroup.addButton(self.tarxzRadio)
# We'll define a compression by default
self.targzRadio.setChecked(True)
# If we don't define blankTile right now it will return an error
self.blankTile = str()
# Signals
self.blankButton.clicked.connect(self.setBlank)
self.saveBox.accepted.connect(self.saveTilemap)
self.saveBox.rejected.connect(self.cancel)
def __init__(self):
# We need this to load the GUI
super(newTilemapWindow, self).__init__()
uic.loadUi(GUI_FOLDER + 'newTm.ui', self)
# Defining labels
self.formatLabel.setText('Format:')
self.resourcesLabel.setText('Tiles Resources:')
self.tileNameLabel.setText('Tilemap Name:')
self.tileSizeSlider.setSliderPosition(DEFAULT_TILE_SIZE)
self.updateSizeLabel()
# And tileSizeSlider range should be the same than
# the constants indicate.
# Also, it should have a proper default position.
self.tileSizeSlider.setMinimum(MIN_TILE_SIZE)
self.tileSizeSlider.setMaximum(MAX_TILE_SIZE)
# Accepted resource formats
self.resourceSuffix = ('.png', '.bmp', '.jpg')
# Now we should define the available formats
self.formatList = [
'TAR Tilemap'
]
# And add the formats into the widget
for f in list(self.formatList):
item = QListWidgetItem(f)
self.formatListWidget.addItem(item)
if f == list(self.formatList)[0]:
self.formatListWidget.setCurrentItem(item)
# Signals and slots
self.chooseButton.clicked.connect(self.pickFolder)
self.tileSizeSlider.valueChanged.connect(self.updateSizeLabel)
self.saveBox.accepted.connect(self.saveTilemap)
self.saveBox.rejected.connect(self.cancel)
def __init__(self, performer, main_window):
super().__init__()
uic.loadUi('ui/notes_management_window.ui', self)
self.main_window = main_window
self.performer = performer
self.shortcut = QtWidgets.QShortcut(QtGui.QKeySequence("Ctrl+F"), self)
self.shortcut.activated.connect(self.trigger_search)
# Add validators on inputs.
self.nickname_input.set_validator(api.validator.NAME)
self.name_input.set_validator(api.validator.NAME)
self.first_name_input.set_validator(api.validator.NAME)
self.mail_input.set_validator(api.validator.MAIL)
self.phone_input.set_validator(api.validator.PHONE_NUMBER)
self.birthdate_input.set_validator(api.validator.BIRTHDATE)
self.photo_selected = None
self.current_nickname = None
self.adding = False
self.categories_added = []
self.current_shown = -1
self.on_change = api.validator.on_change(self, self.save_button)
self.note_list.current_filter = lambda x: True
self.note_list.refresh(api.notes.get())
self.note_list.setFocus(True)
self.show()
def __init__(self):
super(ReportSupply, self).__init__()
loadUi(getcwd() + '/ui/report_supply.ui', self)
self.setWindowIcon(QIcon(getcwd() + "/images/icon.ico"))
self.set_start_settings()
self.set_table_size()
def __init__(self):
super(WarehouseRest, self).__init__()
loadUi(getcwd() + '/ui/warehouse_rest.ui', self)
self.setWindowIcon(QIcon(getcwd() + "/images/icon.ico"))
self.set_size_table()
self.set_start_info()
def __init__(self, *args):
super(DemoImpl, self).__init__(*args)
loadUi('dict2.ui',self)
self.setLayout(self.verticalLayout)
self.plainTextEdit.setReadOnly(True)
self.setWindowFlags(self.windowFlags() |
Qt.WindowSystemMenuHint |
Qt.WindowMinMaxButtonsHint)
self.trayicon = QSystemTrayIcon()
self.traymenu = QMenu()
self.quitAction = QAction('GQuit', self)
self.quitAction.triggered.connect(self.close)
self.quitAction.setShortcut(QKeySequence('Ctrl+q'))
self.addAction(self.quitAction)
self.traymenu.addAction('&Normal', self.showNormal, QKeySequence('Ctrl+n'))
self.traymenu.addAction('Mi&nimize', self.showMinimized, QKeySequence('Ctrl+i'))
self.traymenu.addAction('&Maximum', self.showMaximized, QKeySequence('Ctrl+m'))
self.traymenu.addAction('&Quit',self.close, QKeySequence('Ctrl+q'))
self.trayicon.setContextMenu(self.traymenu)
self.ticon = QIcon('icon_dict2.ico')
self.trayicon.setIcon(self.ticon)
self.trayicon.setToolTip('YYDict')
self.trayicon.activated.connect(self.on_systemTrayIcon_activated)
self.traymsg_firstshow = True
self.button1.clicked.connect(self.searchword)
self.comboBox.activated.connect(self.searchword)
def __init__(self, parent: QWidget=None) -> None:
super(MainWindow, self).__init__(parent)
uic.loadUi(os.path.join(getResourcesPath(), 'ui', 'mainwindow.ui'),
self)
self.actionExit.triggered.connect(QApplication.quit)
self.actionLoad_G_Code.triggered.connect(self.askGCodeFile)
self.actionPrint.triggered.connect(self.actionPrintSlot)
self.actionClear.triggered.connect(self.actionClearSlot)
self.actionZoomIn.triggered.connect(self.zoomIn)
self.actionZoomOut.triggered.connect(self.zoomOut)
self.actionResetZoom.triggered.connect(self.resetZoom)
self.actionSetPenWidth.triggered.connect(self.askPenWidth)
self.actionShowMovement.toggled.connect(self.actionShowMovementSlot)
self.checkBoxActionShowMovement = QCheckBox(
self.actionShowMovement.text(), self.toolBar)
self.checkBoxActionShowMovement.setChecked(True)
# noinspection PyUnresolvedReferences
self.checkBoxActionShowMovement.toggled.connect(
self.actionShowMovementSlot)
self.toolBar.insertWidget(self.actionSetMoveLineColor,
self.checkBoxActionShowMovement)
self.actionSetMoveLineColor.triggered.connect(
self.actionSetMoveLineColorSlot)
self.zoomFactor = 1
self._precision = 1
self._moveLineColor = Qt.green
self.material = None
self.scene = QGraphicsScene()
self.graphicsView.setScene(self.scene)
self.graphicsView.scale(1, -1)
self.graphicsView.setBackgroundBrush(QBrush(Qt.lightGray))
self.clearScene()
self.updateStatusBar()
def __init__(self, parent):
super().__init__()
loadUi('qt_ui/exit_question.ui', self)
self.parent = parent
self.setWindowModality(1)
self.show()
self.initui()
def __init__(self, _filter, parent = None):
super(FilterConfig, self).__init__(parent)
uic.loadUi('GUI/filterConfig.ui', self)
self.filter = _filter
self.buttonBox.accepted.connect(self.save)
self.bAddTrigger.clicked.connect(self.addTrigger)
self.bAddPreprocess.clicked.connect(self.addPreprocess)
self.bDelTrigger.clicked.connect(self.delTrigger)
self.bDelPreprocess.clicked.connect(self.delPreprocess)
self.bOpenFile.clicked.connect(self.openFile)
self.uiName.setText(self.filter.name)
self.uiFormat.setText(self.filter.formatString)
self.uiHeader.setText(self.filter.header)
self.uiOutputFile.setText(self.filter.outputFile)
self.uiLinebreak.setChecked(self.filter.linebreak)
self.uiOverwrite.setChecked(self.filter.overwrite)
self.uiActive.setChecked(self.filter.active)
for (row, trigger) in enumerate(self.filter.trigger):
self.uiTrigger.insertRow(row)
self.uiTrigger.setItem(row, 0, QtWidgets.QTableWidgetItem(','.join(trigger.target)))
self.uiTrigger.setItem(row, 1, QtWidgets.QTableWidgetItem(trigger.pattern))
for (row, preprocess) in enumerate(self.filter.preprocess):
self.uiPreprocess.insertRow(row)
self.uiPreprocess.setItem(row, 0, QtWidgets.QTableWidgetItem(preprocess.action))
self.uiPreprocess.setItem(row, 1, QtWidgets.QTableWidgetItem(preprocess.parameter))
def __init__(self, *args, **kwargs):
super().__init__()
uic.loadUi(self.template, self)
self.setWindowTitle(self.windowTitle() + const.VERSION)
self.center()
self.show()
self.actionNew_connection.triggered.connect(self.add_connection)
def __init__(self, ui_loc, parent=None):
super(SlimWindow, self).__init__(parent)
self.ui_loc = ui_loc
self.ui = uic.loadUi(os.path.join(ui_loc, 'slim.ui'), self)
self.reduction_options_dialog = uic.loadUi(
os.path.join(ui_loc, 'reduction_options.ui'))
# the manual beam finder instance
self.manual_beam_finder = ManualBeamFinder(ui_loc)
# reduction state contains all the file numbers to be reduced
# and all the reduction options information. You could pickle this file
# to save the state of the program
self._reduction_state = ReductionState(
manual_beam_finder=self.manual_beam_finder)
self.ReductionTable = ReductionTableModel(self.reduction_state,
parent=self)
self.ui.file_list.setModel(self.ReductionTable)
# a plot window for displaying datasets
self._plot = SlimPlotWindow(self)
self.output_directory.textChanged.connect(self._plot.data_directory_changed)
def __init__(self, parent):
QWidget.__init__(self, parent)
uic.loadUi(get_ui_file_path('video_info_popup.ui'), self)
self.setWindowFlags(Qt.Window | Qt.FramelessWindowHint)
self.setAttribute(Qt.WA_TranslucentBackground)
def initCentralUic(self):
"""
Load the GUI from the ui file into this class and connect it with event handlers.
"""
# Load the ui file into this class (find it in our own directory)
localDir = os.path.split(__file__)[0]
uic.loadUi(localDir+"/dataExport.ui", self)
self.batchOutputTableWidget.resizeRowsToContents()
self.batchOutputTableWidget.resizeColumnsToContents()
self.batchOutputTableWidget.setAlternatingRowColors(True)
self.batchOutputTableWidget.setShowGrid(False)
self.batchOutputTableWidget.horizontalHeader().setSectionResizeMode(0, QHeaderView.Interactive)
self.batchOutputTableWidget.horizontalHeader().resizeSection(Column.Dataset, 200)
self.batchOutputTableWidget.horizontalHeader().resizeSection(Column.ExportLocation, 250)
self.batchOutputTableWidget.horizontalHeader().resizeSection(Column.Action, 100)
self.batchOutputTableWidget.verticalHeader().hide()
# Set up handlers
self.batchOutputTableWidget.itemSelectionChanged.connect(self.handleTableSelectionChange)
# Set up the viewer area
self.initViewerStack()
self.splitter.setSizes([150, 850])
def __init__(self, project, list_node_ids, opv, *args, **kwargs):
super().__init__(*args, **kwargs)
uic.loadUi('pulse/uix/user_input/ui/loadsInput.ui', self)
icons_path = 'pulse\\data\\icons\\'
self.icon = QIcon(icons_path + 'pulse.png')
self.setWindowIcon(self.icon)
self.project = project
self.transform_points = opv.transformPoints
self.opv = opv
self.project_file_path = project.project_file_path
self.structural_bc_info_path = project.file._nodeStructuralPath
self.userPath = os.path.expanduser('~')
self.new_load_path_table = ""
self.imported_table_name = ""
self.nodes = project.mesh.nodes
self.loads = None
self.nodes_typed = []
self.imported_table = False
self.lineEdit_nodeID = self.findChild(QLineEdit, 'lineEdit_nodeID')
self.lineEdit_real_Fx = self.findChild(QLineEdit, 'lineEdit_real_Fx')
self.lineEdit_real_Fy = self.findChild(QLineEdit, 'lineEdit_real_Fy')
self.lineEdit_real_Fz = self.findChild(QLineEdit, 'lineEdit_real_Fz')
self.lineEdit_real_Mx = self.findChild(QLineEdit, 'lineEdit_real_Mx')
self.lineEdit_real_My = self.findChild(QLineEdit, 'lineEdit_real_My')
self.lineEdit_real_Mz = self.findChild(QLineEdit, 'lineEdit_real_Mz')
self.lineEdit_imag_Fx = self.findChild(QLineEdit, 'lineEdit_imag_Fx')
self.lineEdit_imag_Fy = self.findChild(QLineEdit, 'lineEdit_imag_Fy')
self.lineEdit_imag_Fz = self.findChild(QLineEdit, 'lineEdit_imag_Fz')
self.lineEdit_imag_Mx = self.findChild(QLineEdit, 'lineEdit_imag_Mx')
self.lineEdit_imag_My = self.findChild(QLineEdit, 'lineEdit_imag_My')
self.lineEdit_imag_Mz = self.findChild(QLineEdit, 'lineEdit_imag_Mz')
self.lineEdit_path_table_Fx = self.findChild(QLineEdit,
'lineEdit_path_table_Fx')
self.lineEdit_path_table_Fy = self.findChild(QLineEdit,
'lineEdit_path_table_Fy')
self.lineEdit_path_table_Fz = self.findChild(QLineEdit,
'lineEdit_path_table_Fz')
self.lineEdit_path_table_Mx = self.findChild(QLineEdit,
'lineEdit_path_table_Mx')
self.lineEdit_path_table_My = self.findChild(QLineEdit,
'lineEdit_path_table_My')
self.lineEdit_path_table_Mz = self.findChild(QLineEdit,
'lineEdit_path_table_Mz')
self.toolButton_load_Fx_table = self.findChild(
QToolButton, 'toolButton_load_Fx_table')
self.toolButton_load_Fy_table = self.findChild(
QToolButton, 'toolButton_load_Fy_table')
self.toolButton_load_Fz_table = self.findChild(
QToolButton, 'toolButton_load_Fz_table')
self.toolButton_load_Mx_table = self.findChild(
QToolButton, 'toolButton_load_Mx_table')
self.toolButton_load_My_table = self.findChild(
QToolButton, 'toolButton_load_My_table')
self.toolButton_load_Mz_table = self.findChild(
QToolButton, 'toolButton_load_Mz_table')
self.toolButton_load_Fx_table.clicked.connect(self.load_Fx_table)
self.toolButton_load_Fy_table.clicked.connect(self.load_Fy_table)
self.toolButton_load_Fz_table.clicked.connect(self.load_Fz_table)
self.toolButton_load_Mx_table.clicked.connect(self.load_Mx_table)
self.toolButton_load_My_table.clicked.connect(self.load_My_table)
self.toolButton_load_Mz_table.clicked.connect(self.load_Mz_table)
self.Fx_table = None
self.Fy_table = None
self.Fz_table = None
self.Mx_table = None
self.My_table = None
self.Mz_table = None
self.basename_Fx = None
self.basename_Fy = None
self.basename_Fz = None
self.basename_Mx = None
self.basename_My = None
self.basename_Mz = None
self.tabWidget_nodal_loads = self.findChild(QTabWidget,
"tabWidget_nodal_loads")
self.tab_single_values = self.tabWidget_nodal_loads.findChild(
QWidget, "tab_single_values")
self.tab_table = self.tabWidget_nodal_loads.findChild(
QWidget, "tab_table")
self.treeWidget_nodal_loads = self.findChild(QTreeWidget,
'treeWidget_nodal_loads')
self.treeWidget_nodal_loads.setColumnWidth(1, 20)
self.treeWidget_nodal_loads.setColumnWidth(2, 80)
self.treeWidget_nodal_loads.itemClicked.connect(self.on_click_item)
self.treeWidget_nodal_loads.itemDoubleClicked.connect(
self.on_doubleclick_item)
self.pushButton_single_value_confirm = self.findChild(
QPushButton, 'pushButton_single_value_confirm')
self.pushButton_single_value_confirm.clicked.connect(
self.check_single_values)
self.pushButton_table_values_confirm = self.findChild(
QPushButton, 'pushButton_table_values_confirm')
self.pushButton_table_values_confirm.clicked.connect(
self.check_table_values)
self.pushButton_remove_bc_confirm = self.findChild(
QPushButton, 'pushButton_remove_bc_confirm')
self.pushButton_remove_bc_confirm.clicked.connect(
self.check_remove_bc_from_node)
self.writeNodes(list_node_ids)
self.load_nodes_info()
self.exec_()
def __init__(self):
super(App, self).__init__()
global screenX, screenY, toggleTracking
if (screenX, screenY) == (1920, 1080):
uic.loadUi('eyeWriterInterface-largeMonitor.ui', self)
else:
uic.loadUi('eyeWriterInterface-smallMonitor.ui', self)
self.setGeometry(0, 0, screenX, screenY)
self.xIcon = self.findChild(QtWidgets.QLabel, 'xIcon')
self.xIcon.hide()
self.testTracking = self.findChild(QtWidgets.QLabel, 'testTracking')
self.testTracking.setGeometry(0, 0, screenX, screenY)
self.testTracking.hide()
self.buttons = self.findChild(QtWidgets.QWidget, 'buttons')
self.sliders = self.findChild(QtWidgets.QWidget, 'sliders')
self.buttons.show()
self.sliders.show()
self.frame_label = self.findChild(QtWidgets.QLabel, 'frame_label')
self.frame_label.hide()
self.eye_label = self.findChild(QtWidgets.QLabel, 'eye_label')
self.eye_label.hide()
self.thresholdSlider = self.findChild(QtWidgets.QSlider, 'thresholdSlider')
self.thresholdSlider.valueChanged[int].connect(self.thresholdChanged)
self.zoomSlider = self.findChild(QtWidgets.QSlider, 'zoomSlider')
self.zoomSlider.valueChanged[int].connect(self.zoomChanged)
self.startVideo = self.findChild(QtWidgets.QPushButton, 'startVideo')
self.startVideo.clicked.connect(self.startVideoClicked)
self.menuButton = self.findChild(QtWidgets.QPushButton, 'menuButton')
self.menuButton.clicked.connect(self.menuClicked)
self.menuButton.setIcon(QtGui.QIcon('gear-icon.png'))
self.menuButton.setIconSize(QSize(40, 40))
self.refreshTestScreen = self.findChild(QtWidgets.QPushButton, 'refreshTestScreen')
self.refreshTestScreen.clicked.connect(self.refreshScreen)
self.startTest = self.findChild(QtWidgets.QPushButton, 'startTest')
self.startTest.clicked.connect(self.startTestClicked)
self.toggleLines = self.findChild(QtWidgets.QPushButton, 'toggleLines')
self.toggleLines.clicked.connect(self.toggleLinesClicked)
self.clickCenter = self.findChild(QtWidgets.QPushButton, 'clickCenter')
self.clickCenter.clicked.connect(self.ifCenterClicked)
self.clickCenter.hide()
self.callibrate = self.findChild(QtWidgets.QPushButton, 'callibrate')
self.callibrate.clicked.connect(self.callibrateClicked)
self.thread = videoThread()
self.thread.change_frame_pixmap_signal.connect(self.updateFrameImage)
self.thread.change_eye_pixmap_signal.connect(self.updateEyeImage)
self.thread.change_tracking_pixmap_signal.connect(self.updateTrackingImage)
self.thread.start()
self.show()
def __init__(self):
super().__init__()
uic.loadUi('Main2.ui', self) # Загружаем дизайн
self.Id_button.clicked.connect(self.Init_Group)
self.Date_button.clicked.connect(self.statistic_start)
def __init__(self):
super(OvalFaceFrames, self).__init__()
loadUi('OvalFaceFrames.ui', self)
def __init__(self):
super().__init__()
uic.loadUi('UI.ui', self) # Загружаем дизайн
self.pushButton.clicked.connect(self.paint)
# Обратите внимание: имя элемента такое же как в QTDesigner
self.do_paint = False
def adding_selectiontab(self):
"""add a Tab for additional plot selections
Create a widget, load the selection Ui, add it to the WTabWidget,
prepare everything for the GUI elements to work
"""
tabw = QtWidgets.QWidget()
loadUi(self.ui_file_plotselection, tabw)
tabw.index = len(self.tablist)
self.tablist.append(tabw)
self.tabW_selection.addTab(tabw, "Plot {}".format(tabw.index))
# self.data['axes'].append(dict())
# self.data['data'].append(dict())
# self.data['labels_x'].append('dummy')
# self.data['labels_y'].append('dummy')
# self.data['legend_labels'].append('dummy')
self.selection.append(
dict(X=dict(),
Y1=dict(),
Y2=dict(),
Y3=dict(),
Y4=dict(),
Y5=dict()))
with self.mainthread.dataLock_live:
# all the dictionary keys
instruments = list(self.mainthread.data_live)
instruments.insert(0, "-") # for no chosen value by default
# tabw.comboInstr_X.clear()
# tabw.comboInstr_Y1.clear()
# tabw.comboInstr_Y2.clear()
# tabw.comboInstr_Y3.clear()
# tabw.comboInstr_Y4.clear()
# tabw.comboInstr_Y5.clear()
# for i in axis_instrument: # filling the comboboxes for the instrument
# print(i, type(i))
tabw.comboInstr_X.addItems(instruments)
tabw.comboInstr_Y1.addItems(instruments)
tabw.comboInstr_Y2.addItems(instruments)
tabw.comboInstr_Y3.addItems(instruments)
tabw.comboInstr_Y4.addItems(instruments)
tabw.comboInstr_Y5.addItems(instruments)
# actions in case instruments are chosen in comboboxes
xconf = dict(
GUI_value=tabw.comboValue_X,
GUI_instr=tabw.comboInstr_X,
livevsdb="LIVE",
axis="X",
tab=tabw,
)
y1conf = dict(
GUI_value=tabw.comboValue_Y1,
GUI_instr=tabw.comboInstr_Y1,
livevsdb="LIVE",
axis="Y1",
tab=tabw,
)
y2conf = dict(
GUI_value=tabw.comboValue_Y2,
GUI_instr=tabw.comboInstr_Y2,
livevsdb="LIVE",
axis="Y2",
tab=tabw,
)
y3conf = dict(
GUI_value=tabw.comboValue_Y3,
GUI_instr=tabw.comboInstr_Y3,
livevsdb="LIVE",
axis="Y3",
tab=tabw,
)
y4conf = dict(
GUI_value=tabw.comboValue_Y4,
GUI_instr=tabw.comboInstr_Y4,
livevsdb="LIVE",
axis="Y4",
tab=tabw,
)
y5conf = dict(
GUI_value=tabw.comboValue_Y5,
GUI_instr=tabw.comboInstr_Y5,
livevsdb="LIVE",
axis="Y5",
tab=tabw,
)
tabw.comboInstr_X.currentIndexChanged["int"].connect(
lambda x: self.plot_sel_instr(**xconf))
tabw.comboInstr_Y1.currentIndexChanged["int"].connect(
lambda x: self.plot_sel_instr(**y1conf))
tabw.comboInstr_Y2.currentIndexChanged["int"].connect(
lambda x: self.plot_sel_instr(**y2conf))
tabw.comboInstr_Y3.currentIndexChanged["int"].connect(
lambda x: self.plot_sel_instr(**y3conf))
tabw.comboInstr_Y4.currentIndexChanged["int"].connect(
lambda x: self.plot_sel_instr(**y4conf))
tabw.comboInstr_Y5.currentIndexChanged["int"].connect(
lambda x: self.plot_sel_instr(**y5conf))
def get_test(self):
num_check, snils = ''.join(
self.patient_info[0].text().split()), ''.join(
self.patient_info[1].text().split())
if (not num_check.isdigit()
or len(num_check) != 5) and (not snils.isdigit()
or len(snils) != 11):
self.patient_info[0].setStyleSheet("background-color: #FF0000")
self.patient_info[0].clear()
self.patient_info[1].setStyleSheet("background-color: #FF0000")
self.patient_info[1].clear()
elif not snils.isdigit() or len(snils) != 11:
self.patient_info[0].setStyleSheet("background-color: #FFFFFF")
self.patient_info[1].setStyleSheet("background-color: #FF0000")
self.patient_info[1].clear()
elif not num_check.isdigit() or len(num_check) != 5:
self.patient_info[1].setStyleSheet("background-color: #FFFFFF")
self.patient_info[0].setStyleSheet("background-color: #FF0000")
self.patient_info[0].clear()
else:
con = sqlite3.connect('m_base.db')
cur = con.cursor()
try:
num_file_request = """SELECT number_file FROM tests
WHERE patient_snils = ? AND number = ?"""
num_file = cur.execute(num_file_request,
(snils, num_check)).fetchone()
if num_file:
uic.loadUi('result_form.ui', self)
for el in num_file:
with open(f'{el}.csv') as file_with_result_tests:
reader = csv.reader(file_with_result_tests,
delimiter=';',
quotechar='"')
title = next(reader)
self.tableWidget.setColumnCount(len(title))
self.tableWidget.setHorizontalHeaderLabels(title)
self.tableWidget.setRowCount(0)
for i, row in enumerate(reader):
self.tableWidget.setRowCount(
self.tableWidget.rowCount() + 1)
for j, elem in enumerate(row):
self.tableWidget.setItem(
i, j, QTableWidgetItem(str(elem)))
self.tableWidget.resizeColumnsToContents()
else:
self.patient_info[0].setStyleSheet(
"background-color: #FF0000")
self.patient_info[0].clear()
self.patient_info[1].setStyleSheet(
"background-color: #FF0000")
self.patient_info[1].clear()
except FileExistsError:
self.not_found_lbl = QLabel(self)
self.not_found_lbl.setText(
'Извините, результаты обрабатываются, обратитесь к системе позже'
)
self.not_found_lbl.move(50, 200)
self.not_found_lbl.setFont(
QFont("Source Serif Pro Semibold", 10))
self.not_found_lbl.setStyleSheet("color: #FF0000")
self.not_found_lbl.resize(self.not_found_lbl.sizeHint())
def __init__(self, presenter, parent=None):
super(ListaOperariosView, self).__init__(parent)
self.vistaLista = uic.loadUi("gui/listas/operarios_lista.ui", self)
def __init__(self):
super(Test,self).__init__()
loadUi('madlibs.ui', self)
self.submit.clicked.connect(self.on_click)
def email_verification():
entered_email = register.emailLineEdit.text()
result = service.register(entered_email)
print(result)
def verification_code_check():
verification_code = verification.codelineEdit.text()
result = service.register(verification_code)
print(result)
if __name__ == '__main__':
service = rpyc.connect(host="127.0.0.1", port=12345).root
app = QApplication(sys.argv)
login = loadUi("../ui/login.ui")
register = loadUi("../ui/register.ui")
chat = loadUi("../ui/chat.ui")
verification = loadUi("../ui/verification_code.ui")
login.registerButton.clicked.connect(show_register_panel)
login.loginButton.clicked.connect(login_action)
#register.registerButton.clicked.connect(registeration)
register.registerButton.clicked.connect(show_verification_panel)
#verification.verification_button.clicked.connect(email_verification)
verification.registerButton.clicked.connect(verification_code_check)
chat.sendButton.clicked.connect(send)
login.show()
def __updateSlotsModel(self):
"""
Private slot to update the slots tree display.
"""
self.filterEdit.clear()
try:
dlg = uic.loadUi(self.formFile)
objects = dlg.findChildren(QWidget) + dlg.findChildren(QAction)
signatureList = self.__signatures()
self.slotsModel.clear()
self.slotsModel.setHorizontalHeaderLabels([""])
for obj in objects:
name = obj.objectName()
if not name:
continue
metaObject = obj.metaObject()
className = metaObject.className()
itm = QStandardItem("{0} ({1})".format(name, className))
self.slotsModel.appendRow(itm)
for index in range(metaObject.methodCount()):
metaMethod = metaObject.method(index)
if metaMethod.methodType() == QMetaMethod.Signal:
if qVersion() >= "5.0.0":
itm2 = QStandardItem("on_{0}_{1}".format(
name,
bytes(metaMethod.methodSignature()).decode()))
else:
itm2 = QStandardItem("on_{0}_{1}".format(
name, metaMethod.signature()))
itm.appendRow(itm2)
if self.__module is not None:
if qVersion() >= "5.0.0":
method = "on_{0}_{1}".format(
name,
bytes(metaMethod.methodSignature()).decode(
).split("(")[0])
else:
method = "on_{0}_{1}".format(
name,
metaMethod.signature().split("(")[0])
method2 = "{0}({1})".format(
method, ", ".join([
self.__mapType(t)
for t in metaMethod.parameterTypes()
]))
if method2 in signatureList or \
method in signatureList:
itm2.setFlags(Qt.ItemFlags(Qt.ItemIsEnabled))
itm2.setCheckState(Qt.Checked)
itm2.setForeground(QBrush(Qt.blue))
continue
pyqtSignature = \
", ".join([self.__mapType(t)
for t in metaMethod.parameterTypes()])
parameterNames = metaMethod.parameterNames()
if parameterNames:
for index in range(len(parameterNames)):
if not parameterNames[index]:
parameterNames[index] = \
QByteArray("p{0:d}".format(index))
methNamesSig = \
", ".join(
[bytes(n).decode() for n in parameterNames])
if methNamesSig:
if qVersion() >= "5.0.0":
pythonSignature = \
"on_{0}_{1}(self, {2})".format(
name,
bytes(metaMethod.methodSignature())
.decode().split("(")[0],
methNamesSig)
else:
pythonSignature = \
"on_{0}_{1}(self, {2})".format(
name,
metaMethod.signature().split("(")[0],
methNamesSig)
else:
if qVersion() >= "5.0.0":
pythonSignature = "on_{0}_{1}(self)".format(
name,
bytes(metaMethod.methodSignature()).decode(
).split("(")[0])
else:
pythonSignature = "on_{0}_{1}(self)".format(
name,
metaMethod.signature().split("(")[0])
itm2.setData(pyqtSignature, pyqtSignatureRole)
itm2.setData(pythonSignature, pythonSignatureRole)
itm2.setFlags(
Qt.ItemFlags(Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled
| Qt.ItemIsSelectable))
itm2.setCheckState(Qt.Unchecked)
self.slotsView.sortByColumn(0, Qt.AscendingOrder)
except (AttributeError, ImportError) as err:
E5MessageBox.critical(
self, self.tr("uic error"),
self.tr("""<p>There was an error loading the form <b>{0}</b>"""
""".</p><p>{1}</p>""").format(self.formFile, str(err)))
def __init__(self):
super(Form1, self).__init__()
uic.loadUi('form1.ui',self)
self.btnExit.clicked.connect(self.close)
self.btnNext.clicked.connect(self.next)
def __init__(self):
super().__init__()
uic.loadUi('UI.ui', self)
self.start_paint = False
self.btn.clicked.connect(self.paint)
def add_new_weightUnit(self):
self.new_weightUnit_dialog = QDialog(self.w)
uic.loadUi("app/forms/NewUnit.ui", self.new_weightUnit_dialog)
self.new_weightUnit_dialog_controller = NewWeightUnitDialogController(
self.new_weightUnit_dialog, self.w, self.w.address, self.w.auth)
self.new_weightUnit_dialog.show()
def __init__(self):
QtWidgets.QDialog.__init__(self)
# load the .ui file created in Qt Creator directly
print(f"screen width = {screen_width}")
if screen_width >= 1920:
Interface = uic.loadUi('mainwindow7.ui', self)
else:
Interface = uic.loadUi('mod7.ui', self)
# default values for all parameters
self.S0 = self.slider_S0.value() #100
# call options 1 - 3: strike prices
self.K_C1 = self.slider_K_C1.value()
# put options 1 - 3: strike prices
self.K_P1 = self.slider_K_P1.value()
# call options - times to maturity
self.T_C1 = self.slider_T_C1.value() * .25
# put options - times to maturity
self.T_P1 = self.slider_T_P1.value() * .25
# share parameters
self.r = self.slider_r.value() / 100
self.q = self.slider_q.value() / 100
self.σ = self.slider_sigma.value() / 100
self.μ = self.slider_mu.value() / 100
# share simulation parameters
self.Δt = 0.001
self.seed = 12345
self.simSteps = self.spin_numSteps.value(
) # no. of steps in simulated share price changes; default 5
self.simCurrentStep = 0
self.simY = None
self.Ydiscrete = None
self.circleCoords = []
self.PL_TVOM = [[None for col in range(4)]
for row in range(self.simSteps + 1)
] # initialize matrix (6x4)
self.PL = [[None for col in range(4)]
for row in range(self.simSteps + 1)
] # same as above, but no TVOM
#params = {'S0': log(self.S0), 'K': log(self.K_C), 'r': self.r, 'q': self.q, 'σ': self.σ, 'T': self.T_C, 'seed': self.seed}
#self.params = params
self.NEWSIM = True # Boolean flag to indicate whether a new simulation is necessary
self.button_Simulate.hide()
self.slider_S0.valueChanged.connect(self.on_change_S0)
self.slider_K_C1.valueChanged.connect(self.on_change_K_C1)
self.slider_K_P1.valueChanged.connect(self.on_change_K_P1)
self.slider_T_C1.valueChanged.connect(self.on_change_T_C1)
self.slider_T_P1.valueChanged.connect(self.on_change_T_P1)
self.slider_r.valueChanged.connect(self.on_change_r)
self.slider_q.valueChanged.connect(self.on_change_q)
self.slider_sigma.valueChanged.connect(self.on_change_sigma)
self.slider_mu.valueChanged.connect(self.on_change_mu)
self.button_Simulate.clicked.connect(self.on_click_ShowSimulation)
self.button_NextStep.clicked.connect(self.on_click_NextStep)
self.button_NewSim.clicked.connect(self.on_click_NewSim)
self.spin_numSteps.valueChanged.connect(self.on_valueChange_numSteps)
self.spin_numSteps.visible = False
self.radio_ignore_TVOM.clicked.connect(self.on_click_ignore_TVOM)
self.radio_Profit.clicked.connect(self.on_click_Profit)
self.radio_Payoff.clicked.connect(self.on_click_Payoff)
# initialize default parameter values
# Run some initialization stuff
# simulate a batch of prices
# Initialize all parameter labels
self.label_S0.setText(f"S0 = {self.S0}")
self.label_K_C1.setText(f"K = {self.K_C1}")
self.label_K_P1.setText(f"K = {self.K_P1}")
self.label_T_C1.setText(f"T = {self.T_C1}")
self.label_T_P1.setText(f"T = {self.T_P1}")
self.label_q.setText(f"q = {self.q}")
self.label_r.setText(f"r = {self.r}")
self.label_sigma.setText(f"σ = {self.σ}")
self.label_mu.setText(f"μ = {self.μ}")
self.radio_CoveredCall.clicked.connect(self.on_click_CoveredCall)
self.radio_CoveredCallReverse.clicked.connect(
self.on_click_CoveredCallReverse)
self.radio_ProtectivePut.clicked.connect(self.on_click_ProtectivePut)
self.radio_ProtectivePutReverse.clicked.connect(
self.on_click_ProtectivePutReverse)
self.setGeometry(0, 0, 1366, 768)
# initialize default strategy (Covered Call)
self.on_click_CoveredCall()
self.on_click_NewSim()
def __init__(self, app, main_window):
self.app = app
self.gui = main_window
super(syncPlotWindow, self).__init__()
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.window_closed = False
# Set look and feel
uic.loadUi(self.gui.resourcePath('Sync_Plot_GUI.ui'), self)
#Connect signals
self.status_emit = self.status_signal.emit #Function instance saved so it can later be disconnected explicitly
self.update_emit = self.sync_update_signal.emit #Function instance saved so it can later be disconnected explicitly
self.gui.sync_update_signal.connect(self.update_emit)
self.sync_update_signal.connect(
self.updateWindow
) # Update status when new status signal is received
self.gui.status_signal.connect(
self.status_emit
) # Connect mainWindow status signal to dialog status signal
self.status_signal.connect(
self.updateStatus
) #Update status when new status signal is received
self.plot_timeline = guiMapper.TimeLine(
loopCount=0, interval=STARTING_PLOT_RATE
) # Animation object for animating plots
# Set dark skin if in dark mode since skin is reverted when window is opened.
if self.gui.menu_view_skins_dark.isChecked():
self.app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
else:
self.app.setStyleSheet("")
self.app.setFont(QFont("MS Shell Dlg 2", 12))
#Initialize lists for storing plot data
self.y_ref = [
OrderedDict([("PWM", []), ("Current", []), ("Channel", [])]),
OrderedDict([("PWM", []), ("Current", []), ("Channel", [])])
] #Y values of reference sequence line
self.x_ref = [[], []] #X values of reference sequence line
self.y_values = copy.deepcopy(self.y_ref)
self.x_values = copy.deepcopy(
self.x_ref) # X values of reference sequence line
self.status_dict = copy.deepcopy(self.gui.status_dict)
self.resetStatus()
self.seq_list = guiMapper.initializeSeqList(self.gui)
self.seq_dict = self.gui.seq_dict
self.mode = None #Save active sync mode string
#Plot widget data
self.plots = [
OrderedDict([("PWM", self.graph_intensity_pwm0),
("Current", self.graph_intensity_current0),
("Channel", self.graph_channel0)]),
OrderedDict([("PWM", self.graph_intensity_pwm1),
("Current", self.graph_intensity_current1),
("Channel", self.graph_channel1)])
]
self.state_dict = OrderedDict([("Digital", ["LOW", "HIGH"]),
("Analog", ["Active", "Active"]),
("Confocal", ["Standby", "Scanning"]),
("Serial", ["Active", "Active"]),
("Custom", ["Active", "Active"])])
self.hold_label = [self.hold_label0, self.hold_label1]
#Timers for x-axis
self.plot_interval = STARTING_PLOT_RATE #Time between plot updates in milliseconds
self.plot_start_time = timer(
) # Timer for tracking time points for x_axis
self.hold_start_time = timer(
) # Timer for tracking duration of hold at end of sequence
self.hold_status = [
None, None
] # State of plot hold (None = no hold, False = hold not yet reached, True = in hold)
for plot_dict in self.plots:
for key, value in plot_dict.items():
self.initializePlot(value, key)
self.updateWindow()
conn = sql.Connection("Udet.db")
query = "UPDATE auth SET full_name='{}', gender='{}', dob='{}', pwd='{}' WHERE ref_no={}".format(
name, gender, dob, pwd, ref_id)
conn.execute(query)
conn.commit()
conn.close()
show_edit_detail_page()
suc.show()
# In[14]:
app = QtWidgets.QApplication([])
reg = uic.loadUi("registration.ui")
login = uic.loadUi("login page.ui")
my_detail = uic.loadUi("Details Page.ui")
edit_detail = uic.loadUi("edit details.ui")
read = uic.loadUi("Read Page.ui")
write = uic.loadUi("Write Page.ui")
suc = uic.loadUi("success.ui")
login.show()
login.pushButton.clicked.connect(do_login)
login.pushButton_2.clicked.connect(cancel_login)
login.pushButton_3.clicked.connect(first_register)
reg.pushButton.clicked.connect(do_register)
reg.pushButton_2.clicked.connect(cancel_registration)
def setupGui(self):
self.ui = uic.loadUi(os.path.join(GUIDIR, "labeltool.ui"), self)
# get inserters and items from labels
# FIXME for handling the new-style config correctly
inserters = dict([
(label['attributes']['class'], label['inserter'])
for label in config.LABELS + config.DETAILS
if 'class' in label.get('attributes', {}) and 'inserter' in label
])
items = dict([
(label['attributes']['class'], label['item'])
for label in config.LABELS + config.DETAILS
if 'class' in label.get('attributes', {}) and 'item' in label
])
# Property Editor
self.property_editor = PropertyEditor(config)
# self.ui.dockProperties.setWidget(self.property_editor)
# self.tabwidget = QTabWidget()
# self.tabwidget.addTab(self.property_editor, 'property_editor')
#
# self.itemEditor = ItemEditor(config, self.tabwidget)
# # self.property_editor.setItemEditor(self.itemEditor)
# self.tabwidget.addTab(self.itemEditor, 'item_editor')
# # self.itemEditor.hide()
# self.ui.dockProperties.setWidget(self.tabwidget)
self.ui.dockProperties.setWidget(self.property_editor)
self.itemEditor = ItemEditor(config, self)
# self.property_editor.addItemEditor(self.itemEditor)
self.imageinfo = ImageInfo(config)
self.ui.dockImageInfo.setWidget(self.imageinfo)
# Scene
self.scene = AnnotationScene(self.labeltool,
items=items,
inserters=inserters)
self.property_editor.insertionModeStarted.connect(
self.scene.onInsertionModeStarted)
self.property_editor.insertionModeEnded.connect(
self.scene.onInsertionModeEnded)
# SceneView
self.view = GraphicsView(self)
self.view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.view.setScene(self.scene)
self.central_widget = QWidget()
self.central_layout = QVBoxLayout()
self.controls = ControlButtonWidget()
#give functions as lambdas, or else they will be called with a bool as parameter
self.controls.back_button.clicked.connect(
lambda lt: self.labeltool.gotoPrevious())
self.controls.forward_button.clicked.connect(
lambda lt: self.labeltool.gotoNext())
self.central_layout.addWidget(self.controls)
self.central_layout.addWidget(self.view)
self.central_widget.setLayout(self.central_layout)
self.setCentralWidget(self.central_widget)
self.initShortcuts(config.HOTKEYS)
self.initOptions()
self.initAnnotationMenu()
self.treeview = AnnotationTreeView()
self.treeview.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Preferred)
self.ui.dockAnnotations.setWidget(self.treeview)
self.scene.selectionChanged.connect(self.scene.onSelectionChanged)
self.treeview.selectedItemsChanged.connect(
self.scene.onSelectionChangedInTreeView)
self.scene.itemChanged.connect(self.itemEditor.onItemChanged)
self.scene.itemDisSelected.connect(self.itemEditor.onItemDisSelected)
self.posinfo = QLabel("-1, -1")
self.posinfo.setFrameStyle(QFrame.StyledPanel)
self.statusBar().addPermanentWidget(self.posinfo)
self.scene.mousePositionChanged.connect(self.onMousePositionChanged)
self.image_resolution = QLabel("[no image]")
self.image_resolution.setFrameStyle(QFrame.StyledPanel)
self.statusBar().addPermanentWidget(self.image_resolution)
self.zoominfo = QLabel()
self.zoominfo.setFrameStyle(QFrame.StyledPanel)
self.statusBar().addPermanentWidget(self.zoominfo)
self.view.scaleChanged.connect(self.onScaleChanged)
self.onScaleChanged(self.view.getScale())
self.sb_progress = QProgressBar()
# View menu
self.ui.menu_Views.addAction(self.ui.dockProperties.toggleViewAction())
self.ui.menu_Views.addAction(
self.ui.dockAnnotations.toggleViewAction())
self.ui.menu_Views.addAction(self.ui.dockImageInfo.toggleViewAction())
# Annotation menu
self.copyAnnotations = CopyAnnotations(self.labeltool)
self.interpolateRange = InterpolateRange(self.labeltool)
# Show the UI. It is important that this comes *after* the above
# adding of custom widgets, especially the central widget. Otherwise the
# dock widgets would be far to large.
self.ui.show()
## connect action signals
self.connectActions()
def __init__(self):
super(RecognizePage, self).__init__()
uic.loadUi(os.path.join(uifile, "recognizePage.ui"), self)
import signal
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.Qt import *
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
from collections import deque
import datetime
import threading
import time
from lib import functions
#from lib import gl
app = QtWidgets.QApplication([])
win = uic.loadUi("ui/ChiMeRa.ui") #specify the location of your .ui file
win.resize(1024, 700)
win.show()
functions.setTree(win)
functions.setTree01(win)
functions.setTree02(win)
functions.setTable(win)
#t1 = threading.Thread(target=functions.hello1(win))
#t1 = threading.Timer(1, functions.hello1(win))
#t1.start()
def scheduler():
t = threading.Timer(1, scheduler)
t.start()
def __init__(self, parent=None):
super(GuiCompiling, self).__init__(parent)
uic.loadUi('C:\\Users\\GuSan\\Desktop\\pyqt\\gui_compiling.ui', self)
#self.show()
#self.initUi()
self.download()
def LoginScreen():
user = login.lineEdit.text()
passw = login.lineEdit_2.text()
if user == "zackcmariano" and passw == "1234":
login.close()
logged.show()
else:
login.label_3.setText("Dados de Login Incorretos")
def CloseScreen():
logged.close()
#READING THE UI FILES#
app = QtWidgets.QApplication([])
login = uic.loadUi("login.ui")
register = uic.loadUi("newregister.ui")
logged = uic.loadUi("logged.ui")
login.pushButton.clicked.connect(LoginScreen)
login.pushButton_2.clicked.connect(RegisterScreen)
logged.pushButton.clicked.connect(CloseScreen)
#INSERT IMAGE#
icon = QtGui.QPixmap([])
login.label_4.setPixmap(QtGui.QPixmap('logo.png'))
login.show()
app.exec()
def __init__(self):
super().__init__()
uic.loadUi('Name_phone.ui', self)
self.btn.clicked.connect(self.add)
def __init__(self):
super().__init__()
uic.loadUi('Git и желтые окружности.ui', self) # Загружаем дизайн
self.pushButton.clicked.connect(self.da)
def __init__(self):
"""Initalize required layout variables and add widgets."""
super(AboutPage, self).__init__()
loadUi(ABOUT_DIALOG_PATH, self)
def load(self):
dlg_ = filedir('forms/dlg_connect.ui')
try:
self.ui = uic.loadUi(dlg_, self)
except Exception:
print(traceback.format_exc())
QtWidgets.QMessageBox.information(self, "AVISO",
"No encuentro %s :(" % dlg_)
sys.exit(32)
frameGm = self.frameGeometry()
screen = QtWidgets.QApplication.desktop().screenNumber(
QtWidgets.QApplication.desktop().cursor().pos())
centerPoint = QtWidgets.QApplication.desktop().screenGeometry(
screen).center()
frameGm.moveCenter(centerPoint)
self.move(frameGm.topLeft())
self.ui.pbnStart.clicked.connect(self.on_click)
self.ui.pbnSearchFolder.clicked.connect(self.findPathProject)
# MODIFICACION 4 PARA CONECTOR SQLITE : DEFINIMOS LO QUE HACEN LOS BOTONES nuevos
self.ui.pbnCargarDatos.clicked.connect(self.loadProject)
self.tableWidget.doubleClicked.connect(self.on_click)
# self.ui.pbnMostrarProyectos.clicked.connect(self.ShowTable)
self.ui.pbnBorrarProyecto.clicked.connect(self.deleteProject)
self.ui.pbnGuardarProyecto.clicked.connect(self.saveProject)
self.ui.pbnProyectoEjemplo.clicked.connect(self.saveProjectExample)
self.ui.pbnEnebooImportButton.clicked.connect(self.saveEnebooImport)
# hasta aqui la modificación 4
if not os.path.exists(filedir("../projects")):
os.makedirs(filedir("../projects"))
self.ui.leFolderSQLITE.setText(filedir("../projects"))
self.leName = self.ui.leName
self.leDBName = self.ui.leDBName
self.leUserName = self.ui.leUserName
self.lePassword = self.ui.lePassword
self.lePort = self.ui.lePort
# MODIFICACION 6 PARA CONECTOR SQLITE : DEFINIMOS los NUEVOS CAMPOS DEL UI:
self.leFolder = self.ui.leFolderSQLITE
# self.leDBType = self.ui.leDBType
self.leHostName = self.ui.leHostName
# hasta aqui la modificación 6
self.cBDrivers = self.ui.cBDrivers
DV = PNSqlDrivers()
list = DV.aliasList()
self.cBDrivers.addItems(list)
i = 0
while i < self.cBDrivers.count():
if DV.aliasToName(
self.cBDrivers.itemText(i)) == DV.defaultDriverName:
self.cBDrivers.setCurrentIndex(i)
break
i = i + 1
self.loadPreferences()
self.openDB()
self.ShowTable()
def __init__(self, manager, parent=None):
super().__init__(parent)
self.manager = manager
self.manager.central_state_monitor.add_combined_state_change_listener(
self.update_central_control_buttons_enabled)
# state, state handlers
self.singleton_status = Status()
# path to resources folder
self._path_resources = os.path.normpath(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../",
"resources"))
self._path_modules = self.manager.path_modules
# setup
self.setWindowTitle('JOAN HQ')
self._main_widget = uic.loadUi(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"ui/hq_window.ui"))
self.setCentralWidget(self._main_widget)
self.resize(400, 400)
self._main_widget.btn_quit.setIcon(
QtGui.QIcon(
QtGui.QPixmap(os.path.join(self._path_resources, "quit.png"))))
self._main_widget.btn_quit.setIconSize(QSize(100, 100))
self._main_widget.btn_quit.setFixedSize(QSize(110, 110))
self._main_widget.btn_quit.clicked.connect(self.close)
self._main_widget.btn_initialize.setIcon(
QtGui.QIcon(
QtGui.QPixmap(os.path.join(self._path_resources, "init.png"))))
self._main_widget.btn_initialize.setIconSize(QSize(100, 100))
self._main_widget.btn_initialize.setFixedSize(QSize(110, 110))
self._main_widget.btn_initialize.clicked.connect(self.initialize)
self._main_widget.btn_get_ready.setIcon(
QtGui.QIcon(
QtGui.QPixmap(
os.path.join(self._path_resources, "get_ready.png"))))
self._main_widget.btn_get_ready.setIconSize(QSize(100, 100))
self._main_widget.btn_get_ready.setFixedSize(QSize(110, 110))
self._main_widget.btn_get_ready.clicked.connect(self.get_ready)
self._main_widget.btn_start.setIcon(
QtGui.QIcon(
QtGui.QPixmap(os.path.join(self._path_resources, "run.png"))))
self._main_widget.btn_start.setIconSize(QSize(100, 100))
self._main_widget.btn_start.setFixedSize(QSize(110, 110))
self._main_widget.btn_start.clicked.connect(self.start)
self._main_widget.btn_stop.setIcon(
QtGui.QIcon(
QtGui.QPixmap(os.path.join(self._path_resources, "stop.png"))))
self._main_widget.btn_stop.setIconSize(QSize(100, 100))
self._main_widget.btn_stop.setFixedSize(QSize(110, 110))
self._main_widget.btn_stop.clicked.connect(self.stop)
# dictionary to store all the module widgets
self._module_cards = {}
# add file menu
self._file_menu = self.menuBar().addMenu('File')
self._file_menu.addAction('Quit', self.manager.quit)
self._view_menu = self.menuBar().addMenu('View')
self._view_menu.addAction('Show all current settings..',
self.show_settings_overview)
self._view_menu.addAction('Show performance monitor..',
self.show_performance_monitor)
def __init__(self, app, radarwidget):
super(MainWindow, self).__init__()
self.app = app
if is_osx:
self.app.setWindowIcon(QIcon(os.path.join(settings.gfx_path, 'bluesky.icns')))
else:
self.app.setWindowIcon(QIcon(os.path.join(settings.gfx_path, 'icon.gif')))
uic.loadUi(os.path.join(settings.gfx_path, 'mainwindow.ui'), self)
# list of buttons to connect to, give icons, and tooltips
# the button the icon the tooltip the callback
buttons = { self.zoomin : ['zoomin.svg', 'Zoom in', self.buttonClicked],
self.zoomout : ['zoomout.svg', 'Zoom out', self.buttonClicked],
self.panleft : ['panleft.svg', 'Pan left', self.buttonClicked],
self.panright : ['panright.svg', 'Pan right', self.buttonClicked],
self.panup : ['panup.svg', 'Pan up', self.buttonClicked],
self.pandown : ['pandown.svg', 'Pan down', self.buttonClicked],
self.ic : ['stop.svg', 'Initial condition', self.buttonClicked],
self.op : ['play.svg', 'Operate', self.buttonClicked],
self.hold : ['pause.svg', 'Hold', self.buttonClicked],
self.fast : ['fwd.svg', 'Enable fast-time', self.buttonClicked],
self.fast10 : ['ffwd.svg', 'Fast-forward 10 seconds', self.buttonClicked],
self.sameic : ['frwd.svg', 'Restart same IC', self.buttonClicked],
self.showac : ['AC.svg', 'Show/hide aircraft', self.buttonClicked],
self.showpz : ['PZ.svg', 'Show/hide PZ', self.buttonClicked],
self.showapt : ['apt.svg', 'Show/hide airports', self.buttonClicked],
self.showwpt : ['wpt.svg', 'Show/hide waypoints', self.buttonClicked],
self.showlabels : ['lbl.svg', 'Show/hide text labels', self.buttonClicked],
self.showmap : ['geo.svg', 'Show/hide satellite image', self.buttonClicked],
self.shownodes : ['nodes.svg', 'Show/hide node list', self.buttonClicked]}
for b in buttons.items():
# Set icon
if not b[1][0] is None:
icon = QIcon(os.path.join(settings.gfx_path, 'icons/' + b[1][0]))
b[0].setIcon(icon)
# Set tooltip
if not b[1][1] is None:
b[0].setToolTip(b[1][1])
# Connect clicked signal
b[0].clicked.connect(b[1][2])
# Link menubar buttons
self.action_Open.triggered.connect(app.show_file_dialog)
self.action_Save.triggered.connect(self.buttonClicked)
self.actionBlueSky_help.triggered.connect(app.show_doc_window)
self.radarwidget = radarwidget
radarwidget.setParent(self.centralwidget)
self.verticalLayout.insertWidget(0, radarwidget, 1)
# Connect to manager's nodelist changed signal
manager.instance.nodes_changed.connect(self.nodesChanged)
manager.instance.activenode_changed.connect(self.actnodeChanged)
# Connect widgets with each other
self.console.cmdline_stacked.connect(self.radarwidget.cmdline_stacked)
self.nodetree.setVisible(False)
self.nodetree.setIndentation(0)
self.nodetree.setColumnCount(2)
self.nodetree.setStyleSheet('padding:0px')
self.nodetree.setAttribute(Qt.WA_MacShowFocusRect, False)
self.nodetree.header().resizeSection(0, 130)
self.nodetree.itemClicked.connect(self.nodetreeClicked)
self.hosts = list()
self.nodes = list()
fgcolor = '#%02x%02x%02x' % fg
bgcolor = '#%02x%02x%02x' % bg
self.stackText.setStyleSheet('color:' + fgcolor + '; background-color:' + bgcolor)
self.lineEdit.setStyleSheet('color:' + fgcolor + '; background-color:' + bgcolor)
def add_module(self, module_manager, name=''):
"""
Add a module (in the HQ window and other widgets)
:param module_manager: manager object
:param name: optional
:return:
"""
# create a widget per module (show & close buttons, state)
if name == '':
name = str(module_manager.module)
module_dialog = module_manager.module_dialog
if module_manager.module == JOANModules.CARLA_INTERFACE:
widget = uic.loadUi(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"ui/module_card_carlainterface.ui"))
else:
widget = uic.loadUi(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"ui/module_card.ui"))
widget.setObjectName(name)
widget.grpbox.setTitle(name)
widget.btn_showclose.clicked.connect(module_dialog.toggle_show_close)
widget.btn_showclose.setCheckable(True)
widget.btn_showclose.toggled.connect(
lambda: button_show_close_checked(widget.btn_showclose)
) # change text in the button, based toggle status
module_dialog.closed.connect(lambda: widget.btn_showclose.setChecked(
False)) # if the user closes the dialog, uncheck the button
# Attach connect and disconnect buttons for the carla interface module_card
if module_manager.module == JOANModules.CARLA_INTERFACE:
widget.btn_connect.setEnabled(not module_manager.connected)
widget.btn_disconnect.setEnabled(module_manager.connected)
widget.btn_connect.clicked.connect(module_manager.connect_carla)
widget.btn_disconnect.clicked.connect(
module_manager.disconnect_carla)
widget.btn_connect.clicked.connect(
lambda: widget.btn_connect.setEnabled(not module_manager.
connected))
widget.btn_connect.clicked.connect(
lambda: widget.btn_disconnect.setEnabled(module_manager.
connected))
widget.btn_disconnect.clicked.connect(
lambda: widget.btn_connect.setEnabled(not module_manager.
connected))
widget.btn_disconnect.clicked.connect(
lambda: widget.btn_disconnect.setEnabled(module_manager.
connected))
# with state_machine
try:
module_manager.state_machine.add_state_change_listener(
lambda: self.handle_state_change(widget, module_manager))
self.handle_state_change(widget, module_dialog)
except AttributeError: # display nothing if the module has no state machine
widget.lbl_state.setText(" - ")
# add it to the layout
self._main_widget.module_list_layout.addWidget(widget)
self._main_widget.adjustSize()
self.adjustSize()
# and to the list
self._module_cards[name] = widget
self.handle_state_change(widget, module_manager)
self.update_central_control_buttons_enabled()
def __init__(self, parent=None):
super(GuiStart, self).__init__(parent)
uic.loadUi('c:/cGit/project/src/GUI/gui_start.ui', self)
self.initUi()
