def init_table(self): QTableWidget.clear(self.table) self.table.setRowCount(19) self.table.setColumnCount(4) self.mknum = self.table.rowCount() - 15 row = list(map(str, list(range(1, self.table.rowCount(), 1)))) for i in range(self.mknum): row.insert(0, '') self.table.setVerticalHeaderLabels(row) col = ['', '', '', ''] self.table.setHorizontalHeaderLabels(col) self.table.setSpan(0, 0, 2, 4) self.table.setItem(0, 0, QTableWidgetItem("this is vocabulary")) self.table.item(0, 0).setFont(QFont('Times', 24, QFont.Bold)) for i in range(4): self.table.setColumnWidth(i, self.table.width() / 4 - 9) for i in [0, 2]: self.table.setItem(self.mknum - 1, i, QTableWidgetItem("영어")) self.table.setItem(self.mknum - 1, i + 1, QTableWidgetItem("뜻")) title = ['This is Voca', 'Day : ' + str(self.x), '애플영어', '이름 : '] for k in range(4): self.table.setItem(self.mknum - 2, k, QTableWidgetItem(title[k]))
def sig_to_stems_clicked(self, row): signature = self.sig_to_stems_major_table.item(row, 0).text() print(signature) signature = tuple(signature.split(SEP_SIG)) stems = sorted(self.lexicon.signatures_to_stems()[signature]) number_of_stems_per_column = 5 # create a master list of sublists, where each sublist contains k stems # k = number_of_stems_per_column stem_rows = list() stem_row = list() for i, stem in enumerate(stems, 1): stem_row.append(stem) if not i % number_of_stems_per_column: stem_rows.append(stem_row) stem_row = list() if stem_row: stem_rows.append(stem_row) # set up the minor table as table widget sig_to_stems_minor_table = QTableWidget() sig_to_stems_minor_table.horizontalHeader().hide() sig_to_stems_minor_table.verticalHeader().hide() sig_to_stems_minor_table.clear() sig_to_stems_minor_table.setRowCount(len(stem_rows)) sig_to_stems_minor_table.setColumnCount(number_of_stems_per_column) # fill in the minor table for row, stem_row in enumerate(stem_rows): for col, stem in enumerate(stem_row): item = QTableWidgetItem(stem) sig_to_stems_minor_table.setItem(row, col, item) sig_to_stems_minor_table.resizeColumnsToContents() minor_table_title = QLabel('{} (number of stems: {})' .format(SEP_SIG.join(signature), len(stems)) ) minor_table_widget_with_title = QWidget() layout = QVBoxLayout() layout.addWidget(minor_table_title) layout.addWidget(sig_to_stems_minor_table) minor_table_widget_with_title.setLayout(layout) new_display = QSplitter(Qt.Horizontal) new_display.setHandleWidth(10) new_display.setChildrenCollapsible(False) new_display.addWidget(self.sig_to_stems_major_table) new_display.addWidget(minor_table_widget_with_title) new_display_width = self.majorDisplay.width() / 2 new_display.setSizes( [new_display_width * 0.4, new_display_width * 0.6]) self.load_main_window(major_display=new_display) self.status.clearMessage() self.status.showMessage('{} selected'.format(signature))
def safe_clear_table(table: QtWidgets.QTableWidget, headers: list = None): """Clears the contents from the passed table while preserving its current headers. :param table is a QTableWidget object :param headers is a list of strings representing the new headers to fill the table with. This should be in order from left to right.""" if headers is None: headers = list() _current_headers = [ table.horizontalHeaderItem(column).text() for column in range(table.columnCount()) ] for header in headers: if header not in _current_headers: _current_headers.append(header) table.clear() table.setRowCount(0) for index, header in enumerate(_current_headers): table.setHorizontalHeaderItem(index, QtWidgets.QTableWidgetItem(str(header)))
def cargarTabla(tabla: QtWidgets.QTableWidget, values, columnNames): tabla.clear() tabla.setRowCount(0) tabla.setColumnCount(len(columnNames)) tabla.setHorizontalHeaderLabels(columnNames) tabla.verticalHeader().hide() for rowNumber, rowData in enumerate(values): tabla.insertRow(rowNumber) for columnNumber, columnName in enumerate(columnNames): valor = rowData[columnName] value = f'{valor:0.2f}' if isinstance(valor, float) else f'{valor}' item = QtWidgets.QTableWidgetItem(value) item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled) if isinstance(valor, float) or isinstance(valor, int): item.setTextAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) tabla.setItem(rowNumber, columnNumber, item) tabla.resizeColumnsToContents() currentWidth = 0 for columnNumber, columnName in enumerate(columnNames): currentWidth += tabla.columnWidth(columnNumber) widthToAdd = (tabla.width() - 1 - currentWidth) / len(columnNames) for columnNumber, columnName in enumerate(columnNames): tabla.setColumnWidth(columnNumber, tabla.columnWidth(columnNumber) + widthToAdd)
class titledTable(): def __init__(self, title): self.title = QLabel(title) self.table = QTableWidget() self.table.setShowGrid(True) self.layout = QVBoxLayout() self.layout.addWidget(self.title) self.layout.addWidget(self.table) def clear(self): self.table.setRowCount(0) self.table.setColumnCount(0) self.table.clear() def set_item(self, row, col, item): if isinstance(item, str): self.table.setItem(row, col, QTableWidgetItem(item)) else: print("Type Error: Item must be a str") def num_cols(self, values): value_shape = np.shape(values) numcols = 1 if len(value_shape) > 1: numcols = value_shape[1] return numcols
def sig_to_stems_clicked(self, row): signature = self.sig_to_stems_major_table.item(row, 0).text() print(signature) signature = tuple(signature.split(SEP_SIG)) stems = sorted(self.lexicon.signatures_to_stems()[signature]) number_of_stems_per_column = 5 # create a master list of sublists, where each sublist contains k stems # k = number_of_stems_per_column stem_rows = list() stem_row = list() for i, stem in enumerate(stems, 1): stem_row.append(stem) if not i % number_of_stems_per_column: stem_rows.append(stem_row) stem_row = list() if stem_row: stem_rows.append(stem_row) # set up the minor table as table widget sig_to_stems_minor_table = QTableWidget() sig_to_stems_minor_table.horizontalHeader().hide() sig_to_stems_minor_table.verticalHeader().hide() sig_to_stems_minor_table.clear() sig_to_stems_minor_table.setRowCount(len(stem_rows)) sig_to_stems_minor_table.setColumnCount(number_of_stems_per_column) # fill in the minor table for row, stem_row in enumerate(stem_rows): for col, stem in enumerate(stem_row): item = QTableWidgetItem(stem) sig_to_stems_minor_table.setItem(row, col, item) sig_to_stems_minor_table.resizeColumnsToContents() minor_table_title = QLabel('{} (number of stems: {})' .format(SEP_SIG.join(signature), len(stems))) minor_table_widget_with_title = QWidget() layout = QVBoxLayout() layout.addWidget(minor_table_title) layout.addWidget(sig_to_stems_minor_table) minor_table_widget_with_title.setLayout(layout) new_display = QSplitter(Qt.Horizontal) new_display.setHandleWidth(10) new_display.setChildrenCollapsible(False) new_display.addWidget(self.sig_to_stems_major_table) new_display.addWidget(minor_table_widget_with_title) new_display_width = self.majorDisplay.width() / 2 new_display.setSizes( [new_display_width * 0.4, new_display_width * 0.6]) self.load_main_window(major_display=new_display) self.status.clearMessage() self.status.showMessage('{} selected'.format(signature))
class SelectActivities(QDialog, sweattrails.qt.imports.DownloadManager): select = pyqtSignal() def __init__(self, parent=None): super(SelectActivities, self).__init__(None) layout = QVBoxLayout(self) self.table = QTableWidget(None) self.table.setColumnCount(3) self.table.setHorizontalHeaderLabels(["", "Date", "Size"]) self.table.setColumnWidth(0, 25) self.table.setColumnWidth(1, 100) self.table.setColumnWidth(3, 80) layout.addWidget(self.table) self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.buttonbox.accepted.connect(self.accept) self.buttonbox.rejected.connect(self.reject) self.select.connect(self._select) layout.addWidget(self.buttonbox) self.setMinimumSize(320, 200) self.before_download.connect(parent.before_download) self.after_download.connect(parent.after_download) self.ant_files = None def selectActivities(self, antfiles): logger.debug("SelectActivities.selectActivities") self.ant_files = antfiles self.select.emit() return self._selected def _select(self): logger.debug("SelectActivities._select") self.table.clear() self.table.setRowCount(len(self.ant_files)) for row in range(len(self.ant_files)): f = self.ant_files[row] self.table.setCellWidget(row, 0, QCheckBox(self)) self.table.setItem( row, 1, QTableWidgetItem(f.get_date().strftime("%d %b %Y %H:%M"))) self.table.setItem(row, 2, QTableWidgetItem("{:d}".format(f.get_size()))) result = self.exec_() self._selected = [] if result == QDialog.Accepted: for i in range(len(self.ant_files)): f = self.ant_files[i] cb = self.table.cellWidget(i, 0) if cb.isChecked(): self._selected.append(f)
def clear_table(table: QtWidgets.QTableWidget, headers: list = None): """Clears ALL data from the passed table, including headers. :param table is a QTableWidget object :param headers is a list of strings representing the new headers to fill the table with. This should be in order from left to right.""" table.clear() if headers: set_table_headers(table, headers) else: set_table_headers(table, ["Key", "Value"])
def _setRulerTable(self, tableWidget: QtWidgets.QTableWidget, ruler: Ruler): """ 设置ruler的table。 """ tableWidget.clear() tableWidget.setRowCount(0) tableWidget.verticalHeader().setVisible(False) tableWidget.setColumnCount(7) tableWidget.setHorizontalHeaderLabels( ["区间", "分", "秒", "起", "停", "距离", "旅速"]) tableWidget.setColumnWidth(0, 150) tableWidget.setColumnWidth(1, 40) tableWidget.setColumnWidth(2, 50) tableWidget.setColumnWidth(3, 50) tableWidget.setColumnWidth(4, 50) tableWidget.setColumnWidth(5, 70) tableWidget.setColumnWidth(6, 70) # 方便起见,直接调用line对象 line = ruler.line() station_dicts = line.stations blocker = "->" if ruler.different() else "<->" former_dict = None for i, st_dict in enumerate(station_dicts): if not ruler.isDownPassed(st_dict["zhanming"]): if former_dict is not None: mile = abs(st_dict["licheng"] - former_dict["licheng"]) self._addRulerRow( former_dict["zhanming"], st_dict["zhanming"], blocker, ruler.getInfo(former_dict["zhanming"], st_dict["zhanming"]), tableWidget, mile) former_dict = st_dict former_dict = None if ruler.different(): # 上下行不一致,增加上行部分 for st_dict in reversed(station_dicts): if not ruler.isUpPassed(st_dict["zhanming"]): if former_dict is not None: mile = abs(st_dict["licheng"] - former_dict["licheng"]) self._addRulerRow( former_dict["zhanming"], st_dict["zhanming"], blocker, ruler.getInfo(former_dict["zhanming"], st_dict["zhanming"]), tableWidget, mile) former_dict = st_dict
def fill_table(table: QTableWidget, head=(), data=()): """Clear table and fill with title and data""" table.clear() table.setColumnCount(len(head)) table.setHorizontalHeaderLabels(head) table.setRowCount(len(data)) for i, row in enumerate(data): for j in range(len(row)): elem = row[j] item = QTableWidgetItem(str(elem)) item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) table.setItem(i, j, item) table.resizeColumnsToContents() for i in range(table.colorCount()): table.setColumnWidth(i, table.columnWidth(i) + 50)
def activateParamCell(self, row, paramNum, text, value=None): col_index = self.col_index if paramNum == 1: col = col_index['p1'] else: # assume param 2 col = col_index['p2'] self.activateCell(row, col) # clear and activate nameMask = ~Qt.ItemIsEnabled pname = QTableWidgetItem(text) pname.setBackground(Qt.white) pname.setForeground(Qt.black) flags = pname.flags() pname.setFlags(flags & nameMask) # add 2-cell table cellTable = self.cellWidget(row, col) if isinstance(cellTable, QComboBox): # combo from file selection self.removeCellWidget(row, col) cellTable = None if cellTable is None: cellTable = QTableWidget(self) self.setCellWidget(row, col, cellTable) cellTable.clear() cellTable.setRowCount(1) cellTable.setColumnCount(2) cellTable.horizontalHeader().setVisible(False) cellTable.verticalHeader().setVisible(False) cellTable.setProperty('row', row) cellTable.setProperty('col', col) cellTable.setItem(0, 0, pname) if value is not None: pval = QTableWidgetItem(str(value)) cellTable.setItem(0, 1, pval) if self.viewOnly: flags = pval.flags() pval.setFlags(flags & ~Qt.ItemIsEnabled) pval.setForeground(Qt.black) cellTable.setColumnWidth(0, self.labelWidth) cellTable.setColumnWidth(1, self.paramWidth) cellTable.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) cellTable.cellChanged.connect(self.paramChange) cellTable.setEditTriggers(QAbstractItemView.AllEditTriggers) # Allow single click to edit return cellTable
class jobs_view(QWidget): def __init__(self): QWidget.__init__(self) self.main_vbox = QVBoxLayout() self.tab = QTableWidget() self.tab.resizeColumnsToContents() self.tab.verticalHeader().setVisible(False) # self.tab.cellChanged.connect(self.tab_changed) self.main_vbox.addWidget(self.tab) self.setLayout(self.main_vbox) self.myserver = server_get() self.myserver.jobs_update.connect(self.callback_cluster_get_jobs) self.show() def callback_cluster_get_jobs(self): self.tab.clear() self.tab.setColumnCount(7) self.tab.setRowCount(0) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.tab.setHorizontalHeaderLabels([ _("name"), _("path"), _("ip"), _("start"), _("stop"), _("CPUs"), _("status") ]) for job in self.myserver.jobs: tab_add(self.tab, [ job.name, job.path, job.ip, job.start, job.stop, str(job.cpus), str(job.status) ])
class jobs_view(QWidget): def __init__(self): QWidget.__init__(self) self.main_vbox=QVBoxLayout() self.tab = QTableWidget() self.tab.resizeColumnsToContents() self.tab.verticalHeader().setVisible(False) self.create_model() # self.tab.cellChanged.connect(self.tab_changed) self.main_vbox.addWidget(self.tab) self.setLayout(self.main_vbox) self.show() def add_items(self): self.store.clear() actresses = [("n","name","done","status","target","ip","copystate","start","stop")] for act in actresses: self.store.store.append([act[0], act[1], act[2], act[3],act[4], act[5], act[6], act[7]]) def load_data(self,jobs_list): self.create_model() for i in range(len(jobs_list)): tab_add(self.tab,jobs_list[i]) def create_model(self): self.tab.clear() self.tab.setColumnCount(7) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.tab.setHorizontalHeaderLabels([_("n"), _("done"), _("status"), _("target"), _("ip"),_("copy state"),_("start"),_("stop")]) self.tab.setRowCount(0)
class Widget(QMainWindow): def __init__(self): super().__init__() self.setWindowTitle('Table') self.table_widget = QTableWidget() self.table_widget.cellClicked.connect(self._on_cell_clicked) self.setCentralWidget(self.table_widget) def _on_cell_clicked(self, row, col): selection_model = self.table_widget.selectionModel() selection_model.clear() for i in range(self.table_widget.rowCount()): for j in range(self.table_widget.columnCount()): if i == row or j == col: item = self.table_widget.item(i, j) index = self.table_widget.indexFromItem(item) selection_model.select(index, QItemSelectionModel.Select) def fill(self): self.table_widget.clear() labels = ['ID', 'NAME', 'PRICE'] self.table_widget.setColumnCount(len(labels)) self.table_widget.setHorizontalHeaderLabels(labels) for id_, name, price in [ ['1', 'name_1', 'price_1'], ['2', 'name_2', 'price_2'], ['3', 'name_3', 'price_3'], ]: row = self.table_widget.rowCount() self.table_widget.setRowCount(row + 1) self.table_widget.setItem(row, 0, QTableWidgetItem(str(id_))) self.table_widget.setItem(row, 1, QTableWidgetItem(name)) self.table_widget.setItem(row, 2, QTableWidgetItem(price))
class Window(QWidget): def __init__(self): super(Window, self).__init__() self.resize(400,250) self.setWindowTitle('pythonexplainedto.me speedtest-result') self.table = QTableWidget() self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.refresh = QPushButton() self.refresh.setText("Refresh data") self.refresh.clicked.connect(lambda: self.result()) hbox = QVBoxLayout(self) hbox.addWidget(self.refresh) hbox.addWidget(self.table) self.result() def result(self, values=None): self.table.clear() self.connection = sqlite3.connect("speed.db") self.connection.commit() cursor = self.connection.cursor() if values is None: cursor.execute("SELECT download,upload,ping,date FROM speedtest ORDER BY id DESC") else: cursor.execute("SELECT download,upload,ping,date FROM speedtest ORDER BY id DESC", values) name_of_columns = [e[0] for e in cursor.description] self.table.setColumnCount(len(name_of_columns)) self.table.setRowCount(0) self.table.setHorizontalHeaderLabels(name_of_columns) header = self.table.horizontalHeader() header.setSectionResizeMode(QHeaderView.ResizeToContents) for i, row_data in enumerate(cursor.fetchall()): self.table.insertRow(self.table.rowCount()) for j, value in enumerate(row_data): item = QTableWidgetItem() item.setData(Qt.DisplayRole, value) self.table.setItem(i, j, item)
class PropertyWidget(QtWidgets.QWidget): def __init__(self, parent=None): super(PropertyWidget, self).__init__(parent) HB_lay = QHBoxLayout(self) self.tableWidget = QTableWidget() self.tableWidget.setRowCount(0) self.tableWidget.setColumnCount(3) HB_lay.addWidget(self.tableWidget) HB_lay.addStretch() def display(self, n): try: print('NNNNNNN', n) print('n: ', int(n)) self.tableWidget.setHorizontalHeaderLabels( ['Criteria', 'Weghit', 'min/max']) self.tableWidget.setRowCount(int(n)) except ValueError: self.tableWidget.clear() self.tableWidget.setRowCount(0) def clearTable(self): data = [] model = self.tableWidget.model() for row in range(self.tableWidget.rowCount()): data.append([]) for column in range(model.columnCount()): index = model.index(row, column) # We suppose data are strings data[row].append(str(model.data(index))) self.tableWidget.setRowCount(0) print(data) print('clear Table')
class MainWindow(QWidget): def __init__(self): super().__init__(); self.setGeometry(200, 200, 800, 640); self.initUi(); def initUi(self): self.setWindowTitle("Toy Language") self.grid = QGridLayout() self.grid.setSpacing(10) self.initCodeEditor() self.initVariableTable() self.initButtons() self.setLayout(self.grid) self.show() def initCodeEditor(self): self.codeEditor = CodeEditor(self) self.grid.addWidget(self.codeEditor, 2, 1) defaultCode = """ x = 1; y = 1; z = 2; for i=0 to 100 { for j=0 to 100 { x = x + 1; }; y = y * 2; }; if x > 0 { z = 100; }; """ self.codeEditor.setPlainText(defaultCode) def initVariableTable(self): self.variableTable = QTableWidget() #self.variableTable.setRowCount(8) self.variableTable.setColumnCount(2) self.grid.addWidget(self.variableTable, 2, 2) def initButtons(self): self.btnHBox = QHBoxLayout(); self.btnRun = QPushButton("Run") self.btnSave = QPushButton("Save") self.btnRun.clicked.connect(self.run) self.btnHBox.addWidget(self.btnRun) self.btnHBox.addWidget(self.btnSave) self.grid.addLayout(self.btnHBox, 1, 1) def run(self): content = self.codeEditor.toPlainText() try: astTree = Parser(content).ast self.execAst = ExecuteAst(astTree) self.updateVariableTable() except Exception as e: print(e) def updateVariableTable(self): currentVars = self.execAst.identifiers.dumpMap() self.variableTable.clear() self.variableTable.setRowCount(len(currentVars)) for iNum, iName in enumerate(currentVars): iValue = currentVars[iName] print("<<<" + str(iName) + " - " + str(iValue)) self.variableTable.setItem( iNum, 0, QTableWidgetItem(str(iName))) self.variableTable.setItem( iNum, 1, QTableWidgetItem(str(iValue)))
class MainWindow(QMainWindow): def __init__(self): super().__init__() self.timer = QTimer(self) self.formatted_time = FormattedTime(0, 0, 0) self.state = TimerState.INACTIVE self.splits = [] self.init_menus() self.init_UI() def init_menus(self): menubar = self.menuBar() fileMenu = menubar.addMenu('&File') exitAct = QAction(QIcon('exit.png'), '&Exit', self) exitAct.setShortcut('Ctrl+Q') exitAct.setStatusTip('Exit application') exitAct.triggered.connect(qApp.quit) fileMenu.addAction(exitAct) viewMenu = menubar.addMenu('View') viewStatAct = QAction('View statusbar', self, checkable=True) viewStatAct.setStatusTip('View statusbar') viewStatAct.setChecked(True) viewStatAct.triggered.connect(self.toggle_menu) viewMenu.addAction(viewStatAct) def init_UI(self): wid = QWidget(self) self.setCentralWidget(wid) QToolTip.setFont(QFont('SansSerif', 10)) # --- self.start_stop_button = QPushButton('Start') self.start_stop_button.clicked.connect(self.start_stop) # --- self.pause_button = QPushButton('Pause') self.pause_button.resize(self.pause_button.sizeHint()) self.pause_button.clicked.connect(self.pause_timer) self.pause_button.setEnabled(False) # --- self.split_button = QPushButton("Split") self.split_button.clicked.connect(self.split) self.split_button.setEnabled(False) # --- self.lcd = QLCDNumber(self) self.lcd.setMinimumSize(QSize(150, 150)) self.lcd.setSegmentStyle(QLCDNumber.Flat) self.lcd.setDigitCount(len(str(self.formatted_time))) self.lcd.display(str(self.formatted_time)) # --- self.splits_table = QTableWidget() self.splits_table.setMinimumSize(QSize(150, 200)) self.splits_table.setRowCount(len(self.splits)) self.splits_table.setColumnCount(1) self.splits_table.setShowGrid(False) self.splits_table.verticalHeader().setDefaultSectionSize(20) self.splits_table.verticalHeader().setVisible(False) self.splits_table.horizontalHeader().setVisible(False) self.update_splits_table() # --- vbox = QVBoxLayout() vbox.addStretch(1) vbox.addWidget(self.lcd) vbox.addWidget(self.splits_table) vbox.addWidget(self.start_stop_button) vbox.addWidget(self.pause_button) vbox.addWidget(self.split_button) wid.setLayout(vbox) # --- self.statusBar().showMessage("") self.setGeometry(350, 300, 350, 150) self.setWindowTitle('Timer') self.setWindowIcon(QIcon('web.png')) self.show() def start_stop(self): if self.state == TimerState.ACTIVE: self.state = TimerState.INACTIVE self.timer.stop() self.sender().setText("Start") self.split_button.setEnabled(False) self.pause_button.setEnabled(False) self.statusBar().showMessage("Timer stopped!") elif self.state == TimerState.INACTIVE: self.state = TimerState.ACTIVE self.reset_timer() self.begin_timer() self.sender().setText("Stop") self.split_button.setEnabled(True) self.pause_button.setEnabled(True) self.statusBar().showMessage("Timer started!") elif self.state == TimerState.PAUSED: self.sender().setText("Stop") self.state = TimerState.ACTIVE self.pause_button.setEnabled(True) self.split_button.setEnabled(True) self.begin_timer() def pause_timer(self): self.statusBar().showMessage("Paused!") self.start_stop_button.setText("Start") self.formatted_time.pause() self.pause_button.setEnabled(False) self.state = TimerState.PAUSED self.timer.stop() def split(self): now = FormattedTime(self.formatted_time.minutes, self.formatted_time.seconds, self.formatted_time.centiseconds) self.splits.append(now) self.update_splits_table() def update_current_time(self): self.formatted_time.increment_time() self.lcd.setDigitCount(len(self.formatted_time)) self.lcd.display(str(self.formatted_time)) def begin_timer(self): self.timer.start(10) self.timer.timeout.connect(self.update_current_time) def update_splits_table(self): row = 0 for split in self.splits: self.item = QTableWidgetItem(str(split)) self.splits_table.setRowCount(len(self.splits)) self.splits_table.setItem(row, 0, self.item) row = row + 1 pass def reset_timer(self): self.splits = [] self.splits_table.clear() self.formatted_time = FormattedTime(0, 0, 0) def quit_app(self): sys.exit() def center(self): qr = self.frameGeometry() cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.topLeft()) self.statusBar().showMessage('Moved!') def toggle_menu(self, state): if state: self.statusBar().show() else: self.statusBar().hide() def closeEvent(self, event): if self.state == TimerState.ACTIVE or self.state == TimerState.PAUSED: reply = QMessageBox.question( self, 'Message', "Timer running. Are you sure you want to quit?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No) event.accept() if reply == QMessageBox.Yes else event.ignore() else: event.accept() def keyPressEvent(self, e): if e.key() == Qt.Key_Space: if self.state == TimerState.INACTIVE: self.start_stop() else: self.pause_timer()
class equation_editor(QGroupBox): changed = pyqtSignal() def load(self): lines=[] self.tab.clear() self.tab.setHorizontalHeaderLabels([_("Function"), _("Enabled"), _("a"), _("b"), _("c")]) inp_load_file(lines,self.file_name) print(self.file_name,lines) pos=0 while True: if lines[pos]=="#end": break if lines[pos]=="#ver": break tag=lines[pos] scan_item_add(self.file_name,tag,tag,1) pos=pos+1 #skip hash tag function=lines[pos] #read label pos=pos+1 tag=lines[pos] scan_item_add(self.file_name,tag,tag,1) pos=pos+1 #skip hash tag enabled=lines[pos] #read value pos=pos+1 tag=lines[pos] scan_item_add(self.file_name,tag,tag,1) pos=pos+1 #skip hash tag a=lines[pos] #read value pos=pos+1 tag=lines[pos] scan_item_add(self.file_name,tag,tag,1) pos=pos+1 #skip hash tag b=lines[pos] #read value pos=pos+1 tag=lines[pos] scan_item_add(self.file_name,tag,tag,1) pos=pos+1 #skip hash tag c=lines[pos] #read value pos=pos+1 tab_add(self.tab,[ str(function), str(enabled), str(a), str(b), str(c)]) def __init__(self,file_name,name): QGroupBox.__init__(self) self.file_name=file_name self.name=name self.setTitle(name) self.setStyleSheet("QGroupBox { border: 1px solid gray;}") vbox=QVBoxLayout() self.setLayout(vbox) toolbar=QToolBar() toolbar.setIconSize(QSize(48, 48)) add = QAction(QIcon(os.path.join(get_image_file_path(),"16_add.png")), _("Add "+self.name+" mesh layer"), self) add.triggered.connect(self.add_item_clicked) toolbar.addAction(add) remove = QAction(QIcon(os.path.join(get_image_file_path(),"16_minus.png")), _("Remove "+self.name+" mesh layer"), self) remove.triggered.connect(self.on_remove_click) toolbar.addAction(remove) vbox.addWidget(toolbar) self.tab = QTableWidget() self.tab.resizeColumnsToContents() self.tab.verticalHeader().setVisible(False) self.tab.clear() self.tab.setColumnCount(5) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.load() self.tab.cellChanged.connect(self.tab_changed) vbox.addWidget(self.tab) def tab_changed(self): self.save() self.changed.emit() def add_item_clicked(self): tab_add(self.tab,[ "exp", "true", "a", "b", "c"]) self.save() self.changed.emit() def on_remove_click(self): tab_remove(self.tab) self.save() self.changed.emit() def save(self): lines=[] for i in range(0,self.tab.rowCount()): lines.append("#function_"+str(i)) lines.append(tab_get_value(self.tab,i, 0)) lines.append("#function_enable_"+str(i)) lines.append(tab_get_value(self.tab,i, 1)) lines.append("#function_a_"+str(i)) lines.append(tab_get_value(self.tab,i, 2)) lines.append("#function_b_"+str(i)) lines.append(tab_get_value(self.tab,i, 3)) lines.append("#function_c_"+str(i)) lines.append(tab_get_value(self.tab,i, 4)) lines.append("#ver") lines.append("#1.0") lines.append("#end") inp_write_lines_to_file(self.file_name,lines)
class doping_window(QWidget): lines=[] def save_data(self): print("save") for i in range(0,self.tab.rowCount()): inp_update(self.tab.item(i, 0).text()+".inp", "#doping_start", self.tab.item(i, 2).text()) inp_update(self.tab.item(i, 0).text()+".inp", "#doping_stop", self.tab.item(i, 3).text()) def update(self): self.build_mesh() self.draw_graph() self.fig.canvas.draw() def draw_graph(self): # n=0 self.fig.clf() self.fig.subplots_adjust(bottom=0.2) self.fig.subplots_adjust(left=0.1) self.ax1 = self.fig.add_subplot(111) self.ax1.ticklabel_format(useOffset=False) #ax2 = ax1.twinx() # x_pos=0.0 # layer=0 # color =['r','g','b','y','o','r','g','b','y','o'] self.ax1.set_ylabel(_("Doping (m^{-3})")) x_plot=[] for i in range(0,len(self.x_pos)): x_plot.append(self.x_pos[i]*1e9) frequency, = self.ax1.plot(x_plot,self.doping, 'ro-', linewidth=3 ,alpha=1.0) self.ax1.set_xlabel(_("Position (nm)")) def save_image(self,file_name): self.fig.savefig(file_name) def callback_save(self, widget, data=None): file_name=save_as_gpvdm(self) if file_name!=False: if os.path.splitext(file_name)[1]: self.save_image(file_name) else: filter=dialog.get_filter() self.save_image(file_name+".png") def callback_help(self): webbrowser.open('http://www.gpvdm.com/man/index.html') def load(self): self.tab.blockSignals(True) self.tab.clear() self.tab.setHorizontalHeaderLabels([_("File Name"), _("Width"), _("Start"), _("Stop")]) layers=epitaxy_get_layers() for i in range(0,layers): dos_file=epitaxy_get_dos_file(i) width=epitaxy_get_width(i) if dos_file!="none": lines=[] print("loading",dos_file) if inp_load_file(lines,dos_file+".inp")==True: doping_start=float(inp_search_token_value(lines, "#doping_start")) doping_stop=float(inp_search_token_value(lines, "#doping_stop")) print("add",dos_file) count=self.tab.rowCount() self.tab.insertRow(count) item1 = QTableWidgetItem(str(dos_file)) self.tab.setItem(count,0,item1) item2 = QTableWidgetItem(str(width)) self.tab.setItem(count,1,item2) item3 = QTableWidgetItem(str(doping_start)) self.tab.setItem(count,2,item3) item3 = QTableWidgetItem(str(doping_stop)) self.tab.setItem(count,3,item3) self.tab.blockSignals(False) return def build_mesh(self): # lines=[] self.doping=[] self.x_pos=[] pos=0.0 for i in range(0,self.tab.rowCount()): print(i) doping_start=float(self.tab.item(i, 2).text()) doping_stop=float(self.tab.item(i, 3).text()) width=float(self.tab.item(i, 1).text()) self.doping.append(doping_start) self.x_pos.append(pos) pos=pos+width self.doping.append(doping_stop) self.x_pos.append(pos) return True def callback_close(self, widget, data=None): self.win_list.update(self,"doping") self.hide() return True def tab_changed(self, x,y): self.build_mesh() self.draw_graph() self.fig.canvas.draw() self.save_data() def __init__(self): QWidget.__init__(self) self.win_list=windows() self.setFixedSize(900, 600) self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"doping.png"))) self.setWindowTitle(_("Doping profile editor (www.gpvdm.com)")) self.win_list.set_window(self,"doping") self.main_vbox=QVBoxLayout() toolbar=QToolBar() toolbar.setIconSize(QSize(48, 48)) self.save = QAction(QIcon(os.path.join(get_image_file_path(),"save.png")), _("Save"), self) self.save.triggered.connect(self.callback_save) toolbar.addAction(self.save) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) toolbar.addWidget(spacer) self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), _("Help"), self) self.help.triggered.connect(self.callback_help) toolbar.addAction(self.help) self.main_vbox.addWidget(toolbar) self.fig = Figure(figsize=(5,4), dpi=100) self.ax1=None self.show_key=True canvas = FigureCanvas(self.fig) #canvas.set_background('white') #canvas.set_facecolor('white') canvas.figure.patch.set_facecolor('white') canvas.show() self.main_vbox.addWidget(canvas) self.tab = QTableWidget() self.tab.resizeColumnsToContents() self.tab.verticalHeader().setVisible(False) self.tab.clear() self.tab.setColumnCount(4) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.load() self.build_mesh() self.tab.cellChanged.connect(self.tab_changed) self.main_vbox.addWidget(self.tab) self.draw_graph() self.setLayout(self.main_vbox) return
class mainWin(QMainWindow): def __init__(self) -> None: super(mainWin, self).__init__() self.setWindowTitle("Analysis Main") self.setGeometry(100, 100, 1100, 750) self.statusBar().showMessage("Statusbar - awaiting user control") self.show() self.container = QWidget() self.setCentralWidget(self.container) self.mainLayout = qtw.QHBoxLayout(self.container) self.mainLayout.setSpacing(0) self.mainLayout.setContentsMargins(5, 5, 5, 5) self.splitter = QSplitter(Qt.Horizontal) self.verticalwidgets() self.splitter.addWidget(self.var_table) self.splitter.addWidget(self.tabs_widget) self.mainLayout.addWidget(self.splitter) def verticalwidgets(self) -> None: # left side with the variable explorer self.var_table = QTableWidget() self.var_table.setSelectionBehavior(QTableView.SelectRows) self.var_table.doubleClicked.connect(self.var_table_lr) self.box_layout1 = qtw.QVBoxLayout() self.box_layout1.setContentsMargins(0, 0, 0, 0) self.box_layout1.setSpacing(0) Vheader = self.var_table.verticalHeader() Vheader.setDefaultSectionSize(20) Vheader.setVisible(False) self.var_table.setUpdatesEnabled(True) self.var_table.setColumnWidth(0, 50) self.var_table.setColumnCount(3) cts.update_varlist() self.var_table.setRowCount(len(cts.varlist)) self.updateglobvar_fn() # right side with the tabs self.tabs_widget = QWidget() self.layout = qtw.QHBoxLayout(self.tabs_widget) self.layout.setContentsMargins(0, 0, 0, 0) self.main_panel = QTabWidget() self.calib_tab = calib_win.CalibWin(self) self.rabbit_tab = Rabbit_win.RabbitWin(self) self.main_panel.addTab(self.calib_tab, "Energy calibration") self.main_panel.addTab(self.rabbit_tab, "RABBIT") self.main_panel.currentChanged.connect(self.onTabChange) self.layout.addWidget(self.main_panel) ''' This function updates the values of the variable displayed on the left of the window. The list of the variables is in the glob_var.py file''' def updateglobvar_fn(self) -> None: self.var_table.clear() self.var_table.setColumnCount(3) self.var_table.setRowCount(len(cts.varlist)) self.var_table.setItem(0, 0, QTableWidgetItem("name")) self.var_table.setItem(0, 1, QTableWidgetItem("dtype")) self.var_table.setItem(0, 2, QTableWidgetItem("value")) cts.update_varlist() # updating the content of the variable list for i in range(len(cts.varlist)): var = cts.varlist[i][1] varname = cts.varlist[i][0] self.var_table.setItem(i, 0, QTableWidgetItem(cts.varlist[i][0])) type = self.custom_type_fn(var) self.var_table.setItem(i, 1, QTableWidgetItem(type)) # these 'if's are here to make the variables easily readable if type == "int" or type == "float": if varname == "Ip" or varname == "Vp" or varname == "elow" or varname == "ehigh" or varname == "dE": self.var_table.setItem( i, 2, QTableWidgetItem("{:.2f}".format(var))) elif varname == "L" or varname == "1st harm" or varname == "steps_nm" or varname == "steps_fs" \ or varname == "stepsnb" or varname == "bandsnb": self.var_table.setItem( i, 2, QTableWidgetItem("{}".format(int(var)))) else: self.var_table.setItem( i, 2, QTableWidgetItem("{:.2e}".format(var))) if type == "np.array": self.var_table.setItem(i, 2, QTableWidgetItem(str(var.shape))) if type == "list": self.var_table.setItem(i, 2, QTableWidgetItem(str(len(var)))) if type == "bool": self.var_table.setItem(i, 2, QTableWidgetItem(str(var))) if type == "string": self.var_table.setItem(i, 2, QTableWidgetItem(var)) self.var_table.resizeColumnsToContents() w = 0 for i in range(self.var_table.columnCount()): w = w + self.var_table.columnWidth(i) self.var_table.setFixedWidth(w + 5) def custom_type_fn(self, o) -> str: type = "other" if isinstance(o, int): type = "int" if isinstance(o, float): type = "float" if isinstance(o, np.ndarray): type = "np.array" if isinstance(o, list): type = "list" if isinstance(o, bool): type = "bool" if isinstance(o, str): type = "string" return type ''' function called when double-clicking on a variable''' def var_table_lr(self, doubleClickedIndex) -> None: rowindex = doubleClickedIndex.row() try: vardiag = varDialog(rowindex, self) # new class created below except Exception: print(traceback.format_exception(*sys.exc_info())) ''' Updating elow, ehigh and dE when going from one tab to the other''' def onTabChange(self) -> None: self.calib_tab.elow_le.setText("{:.2f}".format(cts.elow)) self.calib_tab.ehigh_le.setText("{:.2f}".format(cts.ehigh)) self.calib_tab.dE_le.setText("{:.2f}".format(cts.dE)) self.rabbit_tab.elow_le.setText("{:.2f}".format(cts.elow)) self.rabbit_tab.ehigh_le.setText("{:.2f}".format(cts.ehigh)) self.rabbit_tab.dE_le.setText("{:.2f}".format(cts.dE))
class ProdDetail(QWidget): def __init__(self): super().__init__() hbox=QHBoxLayout() hbox2=QHBoxLayout() hbox3=QHBoxLayout() hbox4=QHBoxLayout() self.prod_combo=QComboBox() self.lineEditProdName=QLineEdit() namelabel=QLabel("스토어팜주소") self.farm_combo=QComboBox() self.li=['https://smartstore.naver.com/heyhannah','https://smartstore.naver.com/monsclub'] self.farm_combo.addItems(self.li) self.shop_title_label=QLabel() self.show_farm_name() self.btn_show_prod_detail=QPushButton('조회') self.btn_show_prod_detail.setIcon(QtGui.QIcon('update.png')) hbox.addWidget(namelabel) hbox.addWidget(self.farm_combo) hbox.addWidget(self.shop_title_label) hbox2.addWidget(QLabel("상품명")) hbox2.addWidget(self.prod_combo) hbox2.addStretch() hbox3.addWidget(QLabel("직접입력")) hbox3.addWidget(self.lineEditProdName) hbox3.addWidget(self.btn_show_prod_detail) hbox3.addStretch() self.init_prod_combo() self.btn_show_prod_detail.clicked.connect(self.get_prod_detail) self.farm_combo.currentTextChanged.connect(self.show_farm_name) self.prod_combo.currentTextChanged.connect(self.input_prod_title) vbox=QVBoxLayout() self.linechart=QChart() self.linechart2=QChart() self.linechart3=QChart() self.chartview = QChartView(self.linechart) self.chartview2 = QChartView(self.linechart2) self.chartview3 = QChartView(self.linechart3) self.tablewidget=QTableWidget() self.chartgroup=QGroupBox() self.chartvbox=QVBoxLayout() self.chartvbox.addWidget(self.chartview) self.chartvbox.addWidget(self.chartview2) self.chartvbox.addWidget(self.chartview3) self.chartgroup.setLayout(self.chartvbox) hbox4.addWidget(self.tablewidget) # hbox4.addWidget(self.chartview) hbox4.addWidget(self.chartgroup) self.updateProdDetail() self.groupbox=QGroupBox() self.groupbox2=QGroupBox() self.groupbox3=QGroupBox() self.groupbox4=QGroupBox() self.groupbox.setLayout(hbox) self.groupbox2.setLayout(hbox2) self.groupbox3.setLayout(hbox3) self.groupbox4.setLayout(hbox4) vbox.addWidget(self.groupbox) vbox.addWidget(self.groupbox2) vbox.addWidget(self.groupbox3) vbox.addWidget(self.groupbox4) self.setLayout(vbox) def init_prod_combo(self): mall_url=self.farm_combo.currentText() conn=sqlite3.connect('emaildb.sqlite') cur=conn.cursor() sql=f"Select distinct title from PROD3 where link like '{mall_url}%'" cur.execute(sql) conn.commit() rows=cur.fetchall() li=[] for row in rows: li.append(row[0]) self.prod_combo.clear() self.prod_combo.addItems(li) cur.close() conn.close() self.lineEditProdName.setText(self.prod_combo.currentText()) def drawChart(self): conn=sqlite3.connect('emaildb.sqlite') cur=conn.cursor() title=self.lineEditProdName.text() mall_url=self.farm_combo.currentText() sql=f"select dt, jjim, sold, review from PROD3 where title='{title}'" cur.execute(sql) conn.commit() rows=cur.fetchall() series=[] # series = QLineSeries(self) series.append(QLineSeries(self)) series.append(QLineSeries(self)) series.append(QLineSeries(self)) tod=datetime.today() nextday=datetime.today()+timedelta(days=1) d=QDate(2020,1,3) dt=QDateTime(d) d2=d.addDays(1) dt2=dt.addDays(1) for i,row in enumerate(rows): for j, serie in enumerate(series): # serie.append((dt.addDays(i)).toMSecsSinceEpoch(),int(row[j+1])) serie.append(i,int(row[j+1])) for serie in series: serie.setPointsVisible(True) self.linechart.removeAllSeries() self.linechart2.removeAllSeries() self.linechart3.removeAllSeries() self.linechart.addSeries(series[0]) self.linechart2.addSeries(series[1]) self.linechart3.addSeries(series[2]) dateAxis=QDateTimeAxis() dateAxis2=QDateTimeAxis() dateAxis3=QDateTimeAxis() self.linechart.addAxis(dateAxis, Qt.AlignBottom) self.linechart2.addAxis(dateAxis2, Qt.AlignBottom) self.linechart3.addAxis(dateAxis3, Qt.AlignBottom) self.linechart.createDefaultAxes() self.linechart2.createDefaultAxes() self.linechart3.createDefaultAxes() self.linechart.setAnimationOptions(QChart.SeriesAnimations) self.linechart.setTitle("찜") self.linechart.legend().setVisible(True) self.linechart2.setAnimationOptions(QChart.SeriesAnimations) self.linechart2.setTitle("구매") self.linechart2.legend().setVisible(True) self.linechart3.setAnimationOptions(QChart.SeriesAnimations) self.linechart3.setTitle("리뷰") self.linechart3.legend().setVisible(True) self.chartview.setRenderHint(QPainter.Antialiasing) self.chartview2.setRenderHint(QPainter.Antialiasing) self.chartview3.setRenderHint(QPainter.Antialiasing) cur.close() conn.close() def updateProdDetail(self): self.tablewidget.clear() self.tablewidget.setRowCount(300) self.tablewidget.setColumnCount(6) self.tablewidget.setItem(0,0,QTableWidgetItem("날짜")) self.tablewidget.setItem(0,1,QTableWidgetItem("찜")) self.tablewidget.setItem(0,2,QTableWidgetItem("구매")) self.tablewidget.setItem(0,3,QTableWidgetItem("리뷰")) conn=sqlite3.connect('emaildb.sqlite') cur=conn.cursor() title=self.lineEditProdName.text() mall_url=self.farm_combo.currentText() sql=f"Select dt, jjim, sold, review from PROD3 where title='{title}' order by dt desc" cur.execute(sql) conn.commit() rows=cur.fetchall() for i,row in enumerate(rows): # print(i, row[0]) for j, elem in enumerate(row): # print(i+1,j,elem) # self.tablewidget.setItem(i+1,j,QTableWidgetItem(elem)) self.tablewidget.setItem(i+1,j,QTableWidgetItem(str(row[j]))) # print(row[1]) # self.tablewidget.setItem(i+1,1,QTableWidgetItem(str(row[1]))) self.tablewidget.resizeColumnToContents(0) cur.close() conn.close() return len(rows) def input_prod_title(self): self.lineEditProdName.setText(self.prod_combo.currentText()) def get_prod_detail(self): url=self.farm_combo.currentText() prod_title=self.lineEditProdName.text() self.tablewidget.clear() self.updateProdDetail() self.drawChart() def setFarm(self,li): self.farmlist=FarmList(self.li) # print(self.li) # self.farm_combo.addItems(self.li) self.farmlist.show() def show_farm_name(self): '''스토어팜 주소를 콤보박스에서 변경시에 검색하여 스토어팜 이름 표시 prod_combo도 변경함 ''' # self.shop_title_label.setText("sssss") url=self.farm_combo.currentText() req=requests.get(url) soup=BeautifulSoup(req.text, 'html.parser') self.shop_title_label.setText(soup.find('title').text.strip()) self.init_prod_combo()
class ImageListWidget(QWidget): def __init__(self, parent=None): super(ImageListWidget, self).__init__(parent) self.resize(110, 768) self.setupUi() self.row_last = 0 def setupUi(self): self.icontable = QTableWidget() self.icontable.setColumnCount(2) self.icontable.setColumnWidth(0, 200) self.icontable.setColumnWidth(1, 300) self.icontable.horizontalHeader().setVisible(False) hlayout = QHBoxLayout() hlayout.addWidget(self.icontable) self.setLayout(hlayout) def clear(self): self.row_last = 0 self.icontable.clear() def get_item(self): combox = QComboBox() combox.addItems(['欧拉角', '四元数']) # hlayout = QHBoxLayout() # hlayout.addWidget(combox) return combox def addItem(self, file_name): exif = piexif.load(file_name) thumbnail = exif.pop('thumbnail') if thumbnail is not None: pix = QPixmap() pix.loadFromData(thumbnail, "JPG") else: pix = QPixmap() pix.load(file_name) pix_scaled = pix.scaled(200, 200, Qt.KeepAspectRatio, Qt.SmoothTransformation) label = QLabel("") label.setPixmap(pix_scaled) self.icontable.insertRow(self.row_last) self.icontable.setCellWidget(self.row_last, 0, label) # self.icontable.setItem(self.row_last, 1, QTableWidgetItem("123")) pos = PosItemWidget(QSize(300, pix_scaled.size().height())) self.icontable.setCellWidget(self.row_last, 1, pos) self.icontable.setRowHeight(self.row_last, pix_scaled.size().height()) self.row_last = self.row_last + 1 self.icontable.scrollToBottom() def get_pos(self): quats = np.zeros((self.icontable.rowCount(), 4)) trans = np.zeros((self.icontable.rowCount(), 3)) for row in range(self.icontable.rowCount()): trans[row, :] = np.array([ self.icontable.cellWidget(row, 1).spinbox_tx.value(), self.icontable.cellWidget(row, 1).spinbox_ty.value(), self.icontable.cellWidget(row, 1).spinbox_tz.value() ]) if self.icontable.cellWidget(row, 1).combox.currentText() == '欧拉角': x = self.icontable.cellWidget(row, 1).spinbox_x.value() y = self.icontable.cellWidget(row, 1).spinbox_y.value() z = self.icontable.cellWidget(row, 1).spinbox_z.value() rot_temp = Rotation.from_euler('ZYX', np.array([z, y, x]), degrees=True) quats[row, :] = rot_temp.as_quat() elif self.icontable.cellWidget(row, 1).combox.currentText() == '四元数': x = self.icontable.cellWidget(row, 1).spinbox_x.value() y = self.icontable.cellWidget(row, 1).spinbox_y.value() z = self.icontable.cellWidget(row, 1).spinbox_z.value() w = self.icontable.cellWidget(row, 1).spinbox_w.value() q = np.array([x, y, z, w]) if np.linalg.norm(q) == 0: w = 1 q = np.array([0, 0, 0, 1]) self.icontable.cellWidget(row, 1).spinbox_x.setValue( x / np.linalg.norm(q)) self.icontable.cellWidget(row, 1).spinbox_y.setValue( y / np.linalg.norm(q)) self.icontable.cellWidget(row, 1).spinbox_z.setValue( z / np.linalg.norm(q)) self.icontable.cellWidget(row, 1).spinbox_w.setValue( w / np.linalg.norm(q)) rot_temp = Rotation.from_quat(np.array([x, y, z, w])) quats[row, :] = rot_temp.as_quat() rot = Rotation.from_quat(quats) return rot, trans
class Window(QWidget): def __init__(self): super().__init__() self.title = "mzTabTableWidget" self.top = 100 self.left = 100 self.width = 500 self.height = 500 self.tableRows = 5 self.fileLoaded = False self.PRTFull = [] self.PSMFull = [] self.PRTFiltered = [] self.PSMFiltered = [] self.PRTColumn = [True] self.PSMColumn = [True] self.selectedPRT = "" self.selectedPSM = "" self.tablePRTFull = QTableWidget() self.tablePSMFull = QTableWidget() self.tablePRTFiltered = QTableWidget() self.tablePSMFiltered = QTableWidget() self.vBoxPRT = QVBoxLayout() self.vBoxPSM = QVBoxLayout() self.outerVBox = QVBoxLayout() self.InitWindow() def InitWindow(self): self.setWindowIcon(QtGui.QIcon("icon.png")) self.setWindowTitle(self.title) self.setGeometry(self.top, self.left, self.width, self.height) self.tablePRTFull.setHidden(True) self.tablePSMFull.setHidden(True) self.tablePRTFiltered.setHidden(True) self.tablePSMFiltered.setHidden(True) self.tablePRTFull.itemClicked.connect(self.PRTClicked) self.tablePRTFiltered.itemClicked.connect(self.PRTClicked) self.tablePSMFull.itemClicked.connect(self.PSMClicked) self.tablePSMFiltered.itemClicked.connect(self.PSMClicked) self.tablePRTFull.itemDoubleClicked.connect(self.browsePRT) self.tablePRTFiltered.itemDoubleClicked.connect(self.browsePRT) self.tablePSMFull.itemDoubleClicked.connect(self.browsePSM) self.tablePSMFiltered.itemDoubleClicked.connect(self.browsePSM) self.vBoxPRT.addWidget(self.tablePRTFull) self.vBoxPRT.addWidget(self.tablePRTFiltered) self.vBoxPSM.addWidget(self.tablePSMFull) self.vBoxPSM.addWidget(self.tablePSMFiltered) self.outerVBox.addLayout(self.vBoxPRT) self.outerVBox.addLayout(self.vBoxPSM) self.setLayout(self.outerVBox) self.show() def readFile(self, file): if self.fileLoaded: self.tablePRTFull.clear() self.tablePSMFull.clear() self.tablePSMFiltered.clear() self.tablePRTFiltered.clear() self.tablePRTFull.setRowCount(0) self.tablePSMFull.setRowCount(0) self.tablePSMFiltered.setRowCount(0) self.tablePRTFiltered.setRowCount(0) self.PRTFull.clear() self.PSMFull.clear() self.PRTFiltered.clear() self.PSMFiltered.clear() self.PRTColumn.clear() self.PSMColumn.clear() self.PRTColumn = [True] self.PSMColumn = [True] self.parser(file) self.PRTColumn *= len(self.PRTFull[1]) self.PSMColumn *= len(self.PSMFull[1]) self.initTables() self.createTable(self.tablePRTFull, self.PRTFull) self.createTable(self.tablePSMFull, self.PSMFull) self.hidePRTColumns() self.hidePSMColumns() self.tablePRTFull.setHidden(False) self.tablePSMFull.setHidden(False) self.fileLoaded = True def parser(self, file): """parses the given mzTab file and saves PRT and PSM information Parameters ---------- file : str The file path of the mzTab file """ with open(file) as inp: for line in inp: if line.startswith("PRH"): self.PRTFull.append(line.strip().split('\t')) elif line.startswith( "PRT") and not line.endswith("protein_details\n"): self.PRTFull.append(line.strip().split('\t')) elif line.startswith("PSH") or line.startswith("PSM"): self.PSMFull.append(line.strip().split('\t')) for item in self.PRTFull: item.pop(0) for item in self.PSMFull: item.pop(0) def initTables(self): """draws protein and psm tables with headers""" self.tablePRTFull.setRowCount(len(self.PRTFull)) self.tablePRTFull.setColumnCount(len(self.PRTFull[0])) self.tablePRTFull.setHorizontalHeaderLabels(self.PRTFull[0]) self.tablePSMFull.setRowCount(len(self.PSMFull)) self.tablePSMFull.setColumnCount(len(self.PSMFull[0])) self.tablePSMFull.setHorizontalHeaderLabels(self.PSMFull[0]) self.tablePRTFiltered.setRowCount(0) self.tablePRTFiltered.setColumnCount(len(self.PRTFull[0])) self.tablePRTFiltered.setHorizontalHeaderLabels(self.PRTFull[0]) self.tablePSMFiltered.setRowCount(0) self.tablePSMFiltered.setColumnCount(len(self.PSMFull[0])) self.tablePSMFiltered.setHorizontalHeaderLabels(self.PSMFull[0]) """removes now unnecessary header information from content lists """ self.PRTFull.pop(0) self.PSMFull.pop(0) def createTable(self, table, content): """parameters: tableWidget to draw content in. Content to be drawn in list form""" """Setting count to zero empties the table. Then table is (re-)filled with specified content""" table.setRowCount(0) table.setRowCount(len(content)) j = 0 k = 0 for item in content[0:]: while k < (len(content)): while j < (len(item)): table.setItem(k, j, QTableWidgetItem(item[j])) j += 1 else: k += 1 j = 0 break self.tablePRTFull.resizeColumnsToContents() # resize columns self.tablePSMFull.resizeColumnsToContents() # resize columns self.tablePRTFiltered.resizeColumnsToContents() # resize columns self.tablePSMFiltered.resizeColumnsToContents() # resize columns def hidePRTColumns(self): """hides constant columns in PRT table by default by checking if every value equals""" i = 0 j = 0 k = 0 while i < len(self.PRTFull) - 1: while j < len(self.PRTFull[i]): if self.PRTColumn[j]: if self.PRTFull[i][j] != self.PRTFull[i + 1][j]: self.PRTColumn[j] = False j += 1 i += 1 while k < len(self.PRTColumn): if self.PRTColumn[k]: self.tablePRTFull.setColumnHidden(k, True) self.tablePRTFiltered.setColumnHidden(k, True) k += 1 def hidePSMColumns(self): """hides constant columns in PSM table by default by checking if every value equals""" i = 0 j = 0 k = 0 while i < len(self.PSMFull) - 1: while j < len(self.PSMFull[i]): if self.PSMColumn[j]: if self.PSMFull[i][j] != self.PSMFull[i + 1][j]: self.PSMColumn[j] = False j += 1 i += 1 while k < len(self.PSMColumn): if self.PSMColumn[k]: self.tablePSMFull.setColumnHidden(k, True) self.tablePSMFiltered.setColumnHidden(k, True) k += 1 def PRTClicked(self, item): if self.tablePRTFull.isHidden(): relevantContent = self.PRTFiltered else: relevantContent = self.PRTFull accession = relevantContent[item.row()][0] if self.selectedPSM == accession: self.unfilterPSM() else: self.filterPSM(accession) def PSMClicked(self, item): if self.tablePSMFull.isHidden(): relevantContent = self.PSMFiltered else: relevantContent = self.PSMFull accession = relevantContent[item.row()][2] if self.selectedPRT == accession: self.unfilterPRT() else: self.filterPRT(accession) def filterPRT(self, accession): self.tablePRTFiltered.setHidden(False) self.tablePRTFull.setHidden(True) self.selectedPRT = accession self.PRTFiltered = [ p for p in self.PRTFull if p[0] == self.selectedPRT ] self.createTable(self.tablePRTFiltered, self.PRTFiltered) def filterPSM(self, accession): self.tablePSMFiltered.setHidden(False) self.tablePSMFull.setHidden(True) self.selectedPSM = accession self.PSMFiltered = [ p for p in self.PSMFull if p[2] == self.selectedPSM ] self.createTable(self.tablePSMFiltered, self.PSMFiltered) def unfilterPRT(self): self.tablePRTFiltered.setHidden(True) self.tablePRTFull.setHidden(False) self.selectedPRT = "" self.PRTFiltered = [] def unfilterPSM(self): self.tablePSMFiltered.setHidden(True) self.tablePSMFull.setHidden(False) self.selectedPSM = "" self.PSMFiltered = [] def browsePRT(self, item): if self.tablePRTFull.isHidden(): accession = self.PRTFiltered[item.row()][0].split("|", 2)[1] else: accession = self.PRTFull[item.row()][0].split("|", 2)[1] webbrowser.open("https://www.uniprot.org/uniprot/" + accession) def browsePSM(self, item): if self.tablePSMFull.isHidden(): accession = self.PSMFiltered[item.row()][2].split("|", 2)[1] else: accession = self.PSMFull[item.row()][2].split("|", 2)[1] webbrowser.open("https://www.uniprot.org/uniprot/" + accession)
class rmPeaksDialog(QDialog): ''' created when clicking on the "remove peaks" button''' def __init__(self, parent=CalibWin) -> None: super(rmPeaksDialog, self).__init__(parent) self.par = self.parent() self.currentindex = 0 self.setGeometry(850, 500, 450, 300) self.setWindowTitle("Remove peaks") self.mainlayout = QHBoxLayout() self.rightlayout = QVBoxLayout() self.thirdlayout = QHBoxLayout() self.peaksTable = QTableWidget() self.peaksTable.setSelectionBehavior(QTableView.SelectRows) self.peaksTable.clicked.connect(self.changeindex_lr) self.peaksTable.verticalHeader().sectionClicked.connect( self.changeindex2_lr) self.refreshTable_fn() self.rmpeak_btn = QPushButton("Remove", self) self.ok_btn = QPushButton("Done", self) self.cancel_btn = QPushButton("Cancel", self) self.rmpeak_btn.clicked.connect(self.rmpeak_lr) self.ok_btn.clicked.connect(self.ok_lr) self.cancel_btn.clicked.connect(self.cancel_lr) self.thirdlayout.addWidget(self.ok_btn) self.thirdlayout.addWidget(self.cancel_btn) self.rightlayout.addWidget(self.rmpeak_btn) self.rightlayout.addLayout(self.thirdlayout) self.mainlayout.addWidget(self.peaksTable) self.mainlayout.addLayout(self.rightlayout) self.setLayout(self.mainlayout) self.show() ''' Updating the table''' def refreshTable_fn(self) -> None: self.peaksTable.clear() self.peaksTable.setRowCount(len(self.par.maximaIndices) + 1) self.peaksTable.setColumnCount(2) self.peaksTable.setItem(0, 0, QTableWidgetItem("xcoord")) self.peaksTable.setItem(0, 1, QTableWidgetItem("ycoord")) for i in range(len(self.par.maximaIndices)): self.peaksTable.setItem( i + 1, 0, QTableWidgetItem("{:.3e}".format(self.par.maximaIndices[i]))) self.peaksTable.setItem( i + 1, 1, QTableWidgetItem("{:.3e}".format(self.par.maximaIntensity[i]))) ''' Updating the row index on clicking on the vertical header''' def changeindex2_lr(self, logicalIndex) -> None: self.currentindex = logicalIndex - 1 ''' Updating the row index on clicking anywhere in the row''' def changeindex_lr(self, clickedIndex) -> None: self.currentindex = clickedIndex.row() - 1 ''' "Remove peaks" button listener ''' def rmpeak_lr(self): del self.par.maximaIndices[self.currentindex] del self.par.maximaIntensity[self.currentindex] self.par.refreshplot_fn() self.refreshTable_fn() if (self.currentindex > len(self.par.maximaIndices) - 1): self.peaksTable.selectRow(self.currentindex) self.currentindex -= 1 else: self.peaksTable.selectRow(self.currentindex + 1) ''' "ok" button listener ''' def ok_lr(self) -> None: self.destroy() ''' "cancel" button listener. Calling the parent function "findpeaks_lr" erases all the changes ''' def cancel_lr(self) -> None: self.par.findpeaks_lr() self.par.refreshplot_fn() self.destroy()
class MetaDataViewer(QWidget): """This is the QT Gui that can be used to manipulate the meta data in the Embedding Gui Assumes layout of the meta-data csv has an id followed by pairs of label + color columns id label0 color0 label1 color1 --- labelN colorN . ... ... ... ... --- ... ... . ... ... ... ... --- ... ... """ def __init__(self): """View a composite image based on a subselection of the data """ super(MetaDataViewer, self).__init__() self.class_combo = QComboBox(self) main_layout = QVBoxLayout() form_layout = QFormLayout() form_layout.addRow(QLabel('Class:'), self.class_combo) self.meta_table = QTableWidget(self) self.meta_table.itemSelectionChanged.connect(self.on_change_select) main_layout.addLayout(form_layout) main_layout.addWidget(self.meta_table, 6) self.setLayout(main_layout) self.headers = None self.class_combo.currentIndexChanged[int].connect(self.on_class) self.meta_path = None self.label_series = None self.color_series = None self.labels = None self.string_labels = None self.on_color_change = None self.on_select = None self.dframe = None def init_metadata( self, meta_path=None, on_color_change=None, on_select=None): """Load the meta data and register the meta selection callbacks""" if meta_path is None: return self.on_color_change = on_color_change self.on_select = on_select self.meta_path = meta_path self.headers = pd.read_csv(meta_path, nrows=0) header_names = list(self.headers) self.meta_pairs = [] if len(header_names) % 2 == 0: raise RuntimeError( """Expecting meta data to comprise an id column followed by pairs of label/color columns""") for i in range(1, len(header_names), 2): self.meta_pairs.append([header_names[i], header_names[i + 1]]) self.class_combo.addItem(header_names[i], i) self.class_combo.setCurrentIndex(0) def __fill_table(self): """The table allows the user to select labels""" self.meta_table.clear() # select by row and allow building up multiple selections self.meta_table.setSelectionBehavior(QAbstractItemView.SelectRows) self.meta_table.setSelectionMode(QAbstractItemView.ExtendedSelection) self.meta_table.horizontalHeader().setSectionResizeMode( QHeaderView.ResizeToContents) self.meta_table.setShowGrid(True) self.meta_table.setRowCount(len(self.labels)) self.meta_table.setColumnCount(2) self.meta_table.setHorizontalHeaderLabels(['Group', 'Color']) self.meta_table.verticalHeader().hide() for i, label in enumerate(self.labels): # some label columns are not strings - whodathunkit! self.meta_table.setItem(i, 0, QTableWidgetItem(str(label))) color_item = QTableWidgetItem(' ') lab_col = self.unique_dframe[self.unique_dframe.iloc[:, 0] == label] color_item.setBackground(QColor(lab_col.iloc[0, 1])) self.meta_table.setItem(i, 1, color_item) @pyqtSlot(int) def on_class(self, index): """A new meta data class has been selected. Load and activate the pair of meta columns label + color""" if self.meta_path is None: return cols = self.meta_pairs[index] # load the columns corresponsing to the selected class dframe = pd.read_csv(self.meta_path, usecols=cols) self.label_series = dframe.iloc[:, 0] self.color_series = dframe.iloc[:, 1] self.unique_dframe = dframe.drop_duplicates() self.labels = list(self.label_series.unique()) self.labels.sort() self.__fill_table() # Callback the currently loaded colors self.on_color_change(self.color_series.to_numpy()) @pyqtSlot() def on_change_select(self): """A meta data row has been selected in the table. Convert that to data indexes and callback to the Analysis Controller""" selection = self.meta_table.selectedIndexes() all_indexes = [] for i in selection: group = self.labels[i.row()] group_indexes = list( self.label_series[self.label_series == group].index) all_indexes = all_indexes + group_indexes self.on_select(all_indexes)
class cost(QWidget): def callback_close(self, widget, data=None): self.hide() return True def callback_help(self): webbrowser.open('http://www.gpvdm.com/man/index.html') def __init__(self): QWidget.__init__(self) self.setFixedSize(900, 600) self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"jv.png"))) self.setWindowTitle(_("Cost and energy payback calculator (BETA - missing realistic data at the moment!!!)")) self.main_vbox = QVBoxLayout() toolbar=QToolBar() toolbar.setIconSize(QSize(48, 48)) self.play = QAction(QIcon(os.path.join(get_image_file_path(),"play.png")), "Re-calcualte", self) self.play.triggered.connect(self.update) toolbar.addAction(self.play) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) toolbar.addWidget(spacer) self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), "Help", self) self.help.triggered.connect(self.callback_help) toolbar.addAction(self.help) self.main_vbox.addWidget(toolbar) self.tab= QTableWidget() self.main_vbox.addWidget(self.tab) self.setLayout(self.main_vbox) self.win_list=windows() self.win_list.load() self.win_list.set_window(self,"costs_window") self.update() def update(self): self.tab.clear() self.tab.setColumnCount(5) self.tab.setRowCount(0) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.tab.setHorizontalHeaderLabels([_("material"), _("Volume (m^-3)"), _("Mass (kg)"), _("Cost ($)"), _("Energy (J)")]) self.tab.setColumnWidth(1, 200) self.tab.setColumnWidth(2, 200) self.tab.setColumnWidth(3, 200) self.tab.setColumnWidth(4, 200) energy_tot=0.0 cost_tot=0.0 for i in range(0,epitaxy_get_layers()): volume=epitaxy_get_width(i)*1.0*1.0 name=epitaxy_get_mat_file(i) xls_file_name=os.path.join(get_materials_path(),epitaxy_get_mat_file(i),"cost.xlsx") wb = load_workbook(xls_file_name) ws= wb.get_sheet_by_name("results") density = float(ws['B2'].value) mass=density*volume cost_per_kg = float(ws['B3'].value) cost=mass*cost_per_kg energy_per_kg = float(ws['B4'].value) energy=energy_per_kg*mass tab_add(self.tab,[name,str(volume),str(mass),str(cost),str(energy)]) energy_tot=energy_tot+energy cost_tot=cost_tot+cost pce=inp_get_token_value("sim_info.dat", "#pce") payback_time=-1.0 if pce!=None: pce=float(pce) gen_energy=1366.0*pce/100.0 payback_time=energy_tot/gen_energy/60.0/60.0/24/365 tab_add(self.tab,["sum","","",str(cost_tot),str(energy_tot)]) tab_add(self.tab,["","","pay back time=",str(payback_time),"years"]) def closeEvent(self, event): self.win_list.update(self,"costs_window") self.hide() event.accept()
class contacts_window(QWidget): visible=1 changed = pyqtSignal() def update_contact_db(self): for i in range(0,self.tab.rowCount()): try: float(tab_get_value(self.tab,i, 0)) float(tab_get_value(self.tab,i, 2)) float(tab_get_value(self.tab,i, 3)) float(tab_get_value(self.tab,i, 1)) except: return False contacts_clear() for i in range(0,self.tab.rowCount()): contacts_append(float(tab_get_value(self.tab,i, 0)),float(tab_get_value(self.tab,i, 2)),float(tab_get_value(self.tab,i, 3)),float(tab_get_value(self.tab,i, 1)),str2bool(tab_get_value(self.tab,i, 4))) return True def add_row(self,pos,start,width,depth,voltage,active): pos= tab_insert_row(self.tab) self.tab.blockSignals(True) self.tab.setItem(pos,0,QTableWidgetItem(start)) self.tab.setItem(pos,1,QTableWidgetItem(width)) self.tab.setItem(pos,2,QTableWidgetItem(depth)) self.tab.setItem(pos,3,QTableWidgetItem(voltage)) combobox = QComboBox() combobox.addItem(_("true")) combobox.addItem(_("false")) self.tab.setCellWidget(pos,4, combobox) combobox.setCurrentIndex(combobox.findText(active.lower())) combobox.currentIndexChanged.connect(self.save) self.tab.blockSignals(False) def on_add_clicked(self, button): index = self.tab.selectionModel().selectedRows() if len(index)>0: pos=index[0].row()+1 else: pos = self.tab.rowCount() self.add_row(pos,_("0.0"),_("0.0"),_("0.0"),_("0.0"),_("false")) self.save() def on_remove_clicked(self, button): tab_remove(self.tab) self.save() def save(self): if self.update_contact_db()==True: contacts_save() self.changed.emit() else: error_dlg(self,_("There are some non numberic values in the table")) def callback_close(self, widget, data=None): self.win_list.update(self,"contact") self.hide() return True def callback_help(self): webbrowser.open('http://www.gpvdm.com/man/index.html') def tab_changed(self, x,y): self.save() def load(self): self.tab.clear() self.tab.setHorizontalHeaderLabels([_("Start"), _("Width"),_("Depth"),_("Voltage"),_("Active contact")]) contacts_load() #contacts_print() contacts=contacts_get_array() i=0 for c in contacts_get_array(): self.add_row(i,str(c.start),str(c.width),str(c.depth),str(c.voltage),str(c.active)) i=i+1 def __init__(self): QWidget.__init__(self) self.setFixedSize(600, 400) self.win_list=windows() self.win_list.set_window(self,"contacts") self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"contact.png"))) self.setWindowTitle(_("Edit contacts (www.gpvdm.com)")) self.main_vbox = QVBoxLayout() toolbar=QToolBar() toolbar.setIconSize(QSize(48, 48)) add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add contact"), self) add.triggered.connect(self.on_add_clicked) toolbar.addAction(add) remove = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Remove contacts"), self) remove.triggered.connect(self.on_remove_clicked) toolbar.addAction(remove) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) toolbar.addWidget(spacer) self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), 'Hide', self) self.help.setStatusTip(_("Close")) self.help.triggered.connect(self.callback_help) toolbar.addAction(self.help) self.main_vbox.addWidget(toolbar) self.tab = QTableWidget() self.tab.resizeColumnsToContents() self.tab.verticalHeader().setVisible(False) self.tab.clear() self.tab.setColumnCount(5) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.load() self.tab.cellChanged.connect(self.tab_changed) self.main_vbox.addWidget(self.tab) self.setLayout(self.main_vbox)
class ClassUI(QWidget): def __init__(self): super().__init__() self.initUI() self.re_1 = re.compile(r"^([A-Z]{2,4})(\d{4})") self.re_2 = re.compile(r"^([A-Z]{2,4})-(\d{4})(\d{2})$") def initUI(self): self.layout = QSplitter() self.in_layout = QVBoxLayout() self.table = QTableWidget() self.headers = ['Class', 'Title', 'Amazon', 'Bookstore', 'Edition', 'ISBN', 'Publisher', 'Author', 'Suggested Retail Price', 'Comments', 'Required'] self.table.setColumnCount(len(self.headers)) self.table.setHorizontalHeaderLabels(self.headers) self.table.cellDoubleClicked.connect(self.tableClicked) self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) # self.table.verticalHeader().setSectionResizeMode(QHeaderView.Stretch) self.le = [] for i in range(5): self.le.append(QLineEdit(self)) self.table.setRowCount(len(self.le)) #self.table.setEditTriggers(QAbstractItemView.NoEditTriggers) self.submit_btn = QPushButton('Submit', self) self.submit_btn.clicked.connect(self.submit) self.add_btn = QPushButton('+', self) self.add_btn.clicked.connect(self.add_le) self.rm_btn = QPushButton('-', self) self.rm_btn.clicked.connect(self.rm_le) self.btn_layout = QHBoxLayout() self.in_layout.addWidget(self.submit_btn) self.btn_layout.addWidget(self.add_btn) self.btn_layout.addWidget(self.rm_btn) self.in_layout.addLayout(self.btn_layout) for l in self.le: l.textChanged.connect(self.textChanged) self.in_layout.addWidget(l) self.regex = re.compile("^[A-Z]{2,4}-\d{4}(?:-\d{2})?$") lside = QWidget(self) lside.setLayout(self.in_layout) self.layout.addWidget(lside) self.tab = QTabWidget(self) self.tab.addTab(self.table, 'Books') self.calendar = WeekView() self.tab.addTab(self.calendar, 'Calendar') self.layout.addWidget(self.tab) l = QVBoxLayout() l.addWidget(self.layout) self.setLayout(l) app_icon = QIcon() app_icon.addFile('tulsa.jpg') self.setWindowIcon(app_icon) self.setGeometry(300, 300, 800, 600) self.setWindowTitle('Tulsa class info') self.show() def add_le(self): l = QLineEdit(self) l.textChanged.connect(self.textChanged) self.in_layout.addWidget(l) self.le.append(l) def rm_le(self): l = self.le.pop() self.in_layout.removeWidget(l) l.deleteLater() l = None def textChanged(self): for l in self.le: t = l.text().upper().replace(' ', '-') t = re.sub(self.re_1, r"\1-\2", t) t = re.sub(self.re_2, r"\1-\2-\3", t) l.setText(t) if self.regex.match(l.text()): l.setStyleSheet('color: black') else: l.setStyleSheet('color: red') def tableClicked(self, r, c): if c == 2 or c == 3: cell = self.table.item(r, c) if cell: url = cell.text() if url: QDesktopServices.openUrl(QUrl(url)) def keyPressEvent(self, event): if event.key() == Qt.Key_Escape: self.close() def set_table_item(self, x, y, s): self.table.setItem(x, y, QTableWidgetItem(s)) def submit(self): data = [l.text() for l in self.le if self.regex.match(l.text())] schedule, times = classes.do_stuff(data) self.calendar.refresh() self.table.clear() self.table.setHorizontalHeaderLabels(self.headers) cur_row = 0 for item in times: for tup in item['times']: self.calendar.add_event(tup[0], tup[1], item['name'], item['building'] + ' ' + item['room']) for key in schedule: for book in schedule[key]: self.table.setRowCount(cur_row + 1) if book['Book Title'] != "No Books Required": result = search.ddg_crawl(search.ddg_search(book['Book Title'] + ' ' + book['ISBN'])) bkstr = search.bookstore_get_url(book['Book Title']) self.set_table_item(cur_row, 2, result) self.set_table_item(cur_row, 3, bkstr) self.set_table_item(cur_row, 0, key) self.set_table_item(cur_row, 1, book['Book Title']) self.set_table_item(cur_row, 4, book['Edition']) self.set_table_item(cur_row, 5, book['ISBN']) self.set_table_item(cur_row, 6, book['Publisher']) self.set_table_item(cur_row, 7, book['Author']) self.set_table_item(cur_row, 8, book['Publishers Suggested Retail Price']) self.set_table_item(cur_row, 9, book['Comments']) self.set_table_item(cur_row, 10, book['Required']) cur_row += 1
class DeleteOrphansDirector(QMdiSubWindow): def __init__(self, main): """ Class for delete directors who are orphan in database. :param main: Reference for main windows. """ super(DeleteOrphansDirector, self).__init__() self.session = DB.get_session() self.director = self.session.query(Director) self.main = main window_title = texts.delete_orphans + ' ' + texts.director_p self.setWindowTitle(window_title) self.subwindow = QWidget() p = self.palette() p.setColor(self.backgroundRole(), QColor(230, 230, 250)) self.setPalette(p) self.setWidget(self.subwindow) font = QFont() font.setPointSize(12) # Vbox Main self.vbox_main = QVBoxLayout(self.subwindow) self.vbox_main.setContentsMargins(20, 20, 20, 20) self.vbox_main.setSpacing(10) # Table Cast self.table = QTableWidget() self.table.setColumnCount(2) self.table.setContentsMargins(20, 0, 0, 0) self.table.setHorizontalHeaderLabels([ texts.director_s, 'Del' ]) # table set column width w = int(0.5 * main.frameSize().width()) col_1 = int(0.60 * (w - 50)) col_2 = int(0.20 * (w - 50)) col_width = col_1 + col_2 + 4 self.table.setColumnWidth(0, col_1) self.table.setColumnWidth(1, col_2) self.table.rowHeight(30) self.table.setFixedWidth(col_width) self.table.horizontalHeader().setFont(font) self.table.horizontalHeader().setStyleSheet( 'background-color: rgb(230, 230, 230);') self.table.verticalHeader().setVisible(False) self.rows = 0 self.ch_del = [] self.vbox_main.addWidget(self.table) # Buttons self.pb_delete = pb_create(texts.pb_delete, 12, 40) self.pb_delete.setMinimumHeight(40) self.pb_delete.setShortcut('Ctrl+D') self.pb_delete.clicked.connect(self.delete) self.pb_leave = pb_create(texts.pb_leave, 12, 40) self.pb_leave.setMinimumHeight(40) self.pb_leave.setShortcut('Ctrl+Q') self.pb_leave.clicked.connect(self.close) self.pb_help = pb_create(texts.pb_help, height=40) self.pb_help.setMinimumHeight(40) self.pb_help.clicked.connect(self.help) self.pb_help.setShortcut('Ctrl+H') self.pb_select_all = pb_create(texts.pb_select_all, 12, 40) self.pb_select_all.setMinimumHeight(40) self.pb_select_all.setShortcut('Ctrl+A') self.pb_select_all.clicked.connect(self.select_all) self.hb_pb = QHBoxLayout() self.hb_pb.setSpacing(10) self.hb_pb.addWidget(self.pb_delete) self.hb_pb.addWidget(self.pb_leave) self.hb_pb.addWidget(self.pb_help) self.hb_pb.addWidget(self.pb_select_all) self.vbox_main.addLayout(self.hb_pb) self.width = col_width + 44 self.height = int(0.8 * main.frameSize().height()) self.setGeometry(0, 0, self.width, self.height) self.create_table() def create_table(self): """ Create a table for show all orphan directors info and with a QCheckBox that if is check the actor will be delete. """ sub = self.session.query(MovieDirector.director_id) sub = sub.distinct() director_result = self.director.filter(Director.id.notin_(sub)).all() for director in director_result: self.table.insertRow(self.rows) self.table.setItem(self.rows, 0, QTableWidgetItem(director.name)) ch_del = QCheckBox(str(director.id)) self.ch_del.append(ch_del) hb_del = hbox_create([self.ch_del[self.rows]], 0) hb_del.setAlignment(Qt.AlignCenter) cell_del = QWidget() cell_del.setLayout(hb_del) self.table.setCellWidget(self.rows, 1, cell_del) if self.rows % 2 != 0: self.table.item(self.rows, 0).setBackground( QColor(230, 230, 230) ) self.table.cellWidget(self.rows, 1).setStyleSheet( 'background-color: #E6E6E6;' 'color: #E6E6E6;' ) else: self.table.cellWidget(self.rows, 1).setStyleSheet( 'color: #FFFFFF;' ) self.table.item(self.rows, 0).setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled ) self.rows += 1 height = self.rows * 30 + 20 self.table.setMinimumHeight(height) self.height = height + 130 self.setGeometry(0, 0, self.width, self.height) def delete(self): """ Delete director from database. """ delete_orphans(self.session, self.ch_del, Director, texts.director_s) self.clear() self.create_table() def select_all(self): """ Mark all delete QCheckBox. """ for ch in self.ch_del: ch.setChecked(True) # Clear def clear(self): """ Call for help. :return: Show a help view. """ for row in range(self.rows): self.table.removeRow(row) self.table.clear() self.table.setRowCount(0) self.rows = 0 self.ch_del = [] self.session.expire_all() # Help def help(self): # I have to perform help preview functions on the main because the bug # "stack_trace posix.cc (699)" does not let the page find its directory. dir = os.getcwd() url = 'file:///' + dir + '/views_help/help_delete_orphans.html' self.main.views_help(url, texts.help_edit_movie) # Close Event def closeEvent(self, event): self.session.close()
class AccountDialog(QDialog): selected = QtCore.pyqtSignal(int, bool) aborted = QtCore.pyqtSignal() def __init__(self, parent, accountman): QDialog.__init__(self, parent) self.accountman = accountman layout = QVBoxLayout() self.setWindowTitle('Select Account') # Create list self.table = QTableWidget() self.table.horizontalHeader().setHighlightSections(False) self.table.setSelectionMode(QAbstractItemView.SingleSelection) self.table.setSelectionBehavior(QAbstractItemView.SelectRows) self.table.setEditTriggers(QAbstractItemView.NoEditTriggers) self.table.verticalHeader().hide() self.table.setGridStyle(QtCore.Qt.NoPen) self.table.doubleClicked.connect(self.select) bottom_layout = QHBoxLayout() self.remember_chk = QCheckBox('Remember') cancel_btn = QPushButton('Cancel') cancel_btn.clicked.connect(self.cancel) add_btn = QPushButton('Add') add_btn.clicked.connect(self.add) self.edit_btns = QComboBox() self.edit_btns.blockSignals(True) self.edit_btns.addItem('Edit...') self.edit_btns.addItem('Update') self.edit_btns.addItem('Delete') self.edit_btns.addItem('Purge') self.edit_btns.setItemData(1, 'Change the local password/PIN for this account', QtCore.Qt.ToolTipRole) self.edit_btns.setItemData(2, 'Remove this account from Trackma', QtCore.Qt.ToolTipRole) self.edit_btns.setItemData(3, 'Clear local DB for this account', QtCore.Qt.ToolTipRole) self.edit_btns.setCurrentIndex(0) self.edit_btns.blockSignals(False) self.edit_btns.activated.connect(self.s_edit) select_btn = QPushButton('Select') select_btn.clicked.connect(self.select) select_btn.setDefault(True) bottom_layout.addWidget(self.remember_chk) bottom_layout.addWidget(cancel_btn) bottom_layout.addWidget(add_btn) bottom_layout.addWidget(self.edit_btns) bottom_layout.addWidget(select_btn) # Get icons self.icons = dict() for libname, lib in utils.available_libs.items(): self.icons[libname] = QtGui.QIcon(lib[1]) # Populate list self.update() self.rebuild() # Finish layout layout.addWidget(self.table) layout.addLayout(bottom_layout) self.setLayout(layout) def update(self): self.remember_chk.setChecked(self.accountman.get_default() is not None) def add(self): result = AccountAddDialog.do(icons=self.icons) if result: (username, password, api) = result self.accountman.add_account(username, password, api) self.rebuild() def edit(self): self.edit_btns.blockSignals(True) self.edit_btns.setCurrentIndex(0) self.edit_btns.blockSignals(False) try: selected_account_num = self.table.selectedItems()[0].num acct = self.accountman.get_account(selected_account_num) result = AccountAddDialog.do(icons=self.icons, edit=True, username=acct['username'], password=acct['password'], api=acct['api']) if result: (username, password, api) = result self.accountman.edit_account(selected_account_num, username, password, api) self.rebuild() except IndexError: self._error("Please select an account.") def delete(self): try: selected_account_num = self.table.selectedItems()[0].num reply = QMessageBox.question(self, 'Confirmation', 'Do you want to delete the selected account?', QMessageBox.Yes, QMessageBox.No) if reply == QMessageBox.Yes: self.accountman.delete_account(selected_account_num) self.rebuild() except IndexError: self._error("Please select an account.") def purge(self): try: selected_account_num = self.table.selectedItems()[0].num reply = QMessageBox.question(self, 'Confirmation', 'Do you want to purge the selected account\'s local data?', QMessageBox.Yes, QMessageBox.No) if reply == QMessageBox.Yes: self.accountman.purge_account(selected_account_num) self.rebuild() except IndexError: self._error("Please select an account.") def s_edit(self, index): if index is 1: self.edit() elif index is 2: self.delete() elif index is 3: self.purge() def rebuild(self): self.table.clear() columns = ['Username', 'Site'] self.table.setColumnCount(len(columns)) self.table.setHorizontalHeaderLabels(columns) self.table.setRowCount(len(self.accountman.accounts['accounts'])) accounts = self.accountman.get_accounts() i = 0 for k, account in accounts: self.table.setRowHeight(i, QtGui.QFontMetrics(self.table.font()).height() + 2) self.table.setItem(i, 0, AccountItem(k, account['username'])) self.table.setItem(i, 1, AccountItem(k, account['api'], self.icons.get(account['api']))) i += 1 if pyqt_version is 5: self.table.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch) else: self.table.horizontalHeader().setResizeMode(0, QHeaderView.Stretch) def select(self, checked): try: selected_account_num = self.table.selectedItems()[0].num self.selected.emit(selected_account_num, self.remember_chk.isChecked()) self.close() except IndexError: self._error("Please select an account.") def cancel(self, checked): self.aborted.emit() self.close() def _error(self, msg): QMessageBox.critical(self, 'Error', str(msg), QMessageBox.Ok)
class StatisticsWidget(QWidget): def __init__(self, parent, game): super().__init__(parent) self.parent = parent self.game = game self.title = "Statistics" self.left = 0 self.top = 0 self.width = 1000 self.height = 800 self.initUI() def initUI(self): """ initialize the widget parameter """ self.setWindowTitle(self.title) # print(self.parent.minimumSizeHint().height()) self.setGeometry(self.left, self.top, self.width, self.height) self.table_widget = QTableWidget() self.table_widget.setRowCount(32) # attributes num_individuals = self.parent.parent_window.config.global_config[ 'num_individuals'] * 2 self.table_widget.setColumnCount(num_individuals) # individuals self.display_statistics() self.layout = QVBoxLayout() self.layout.addWidget(self.table_widget) self.setLayout(self.layout) # self.resize(self.sizeHint().width(), self.sizeHint().height()) self.show() def reload(self, game): """ reloads all statistics with the given game instance """ self.game = game self.table_widget.clear() def update(self): """ redraw statistics """ self.display_statistics() def display_statistics(self): """ create a table for statistics for all individuals """ populations = ["pop1", "pop2"] header = [] for pop in populations: for i in range(len(self.game.game_objects[pop])): header.append(self.game.colors[pop][1] + " #" + str(i + 1)) # self.table_widget.setSpan(1,0,7,0) # setItem(row, column, item) self.table_widget.setHorizontalHeaderLabels(header) v_header_labels = [ "Dead", "Frames Survived", "Food Perception", "Poison Perception", "Heal Potion Perception", "Corpse Perception", "Opponent Perception", "Predator Perception", "Seek Food Desire", "Dodge Poison Desire", "Seek Heal Potion Desire", "Seek Opponents Desire", "Seek Corpse Desire", "Dodge Predators Desire", "Increased Armor", "Increased Speed", "Increased Poison Resistance", "Strength", "Toxicity", "Food Eaten", "Poison Eaten", "Consumed Heal Potions", "Consumed Corpses", "Attacked Enemies", "Attacked by Opponents", "Attacked by Predators", "Food Seen", "Poison Seen", "Heal Potion Seen", "Opponent Seen", "Predator Seen", "Corpse Seen" ] self.table_widget.setVerticalHeaderLabels(v_header_labels) pop_offset = 0 for pop in populations: index = 0 for individual in self.game.game_objects[pop]: individual.statistic_to_table(self.table_widget, pop_offset + index) index += 1 pop_offset += len(self.game.game_objects[pop])
def create_major_display_table(input_iterable, key=lambda x: x, reverse=False, headers=None, row_cell_functions=None, cutoff=0, set_text_alignment=None): """ This is a general function for creating a tabular display for the major display. """ if not input_iterable: print('Warning: input is empty', flush=True) return if not hasattr(input_iterable, '__iter__'): print('Warning: input is not an iterable', flush=True) return number_of_headers = len(headers) number_of_columns = len(row_cell_functions) if number_of_headers != number_of_columns: print('headers and cell functions don\'t match', flush=True) return len_input = len(input_iterable) table_widget = QTableWidget() table_widget.clear() table_widget.setSortingEnabled(False) # set up row count if cutoff and cutoff < len_input: actual_cutoff = cutoff else: actual_cutoff = len_input table_widget.setRowCount(actual_cutoff) # set up column count and table headers table_widget.setColumnCount(number_of_headers) table_widget.setHorizontalHeaderLabels(headers) # fill in the table for row, x in enumerate(double_sorted(input_iterable, key=key, reverse=reverse)): for col, fn in enumerate(row_cell_functions): cell = fn(x) if isinstance(cell, (int, float)): # cell is numeric item = QTableWidgetItem() item.setData(Qt.EditRole, cell) else: # cell is not numeric item = QTableWidgetItem(cell) if set_text_alignment: for align_col, alignment in set_text_alignment: if col == align_col: item.setTextAlignment(alignment) table_widget.setItem(row, col, item) if not row < actual_cutoff: break table_widget.setSortingEnabled(True) table_widget.resizeColumnsToContents() return table_widget
class MyStorFarm(QWidget): def __init__(self): super().__init__() hbox=QHBoxLayout() hbox2=QHBoxLayout() namelabel=QLabel("스토어팜주소") self.farm_combo=QComboBox() self.li=['https://smartstore.naver.com/heyhannah','https://smartstore.naver.com/monsclub'] self.farm_combo.addItems(self.li) self.shop_title_label=QLabel() self.show_farm_name() self.btn_show_prod=QPushButton('조회') self.btn_show_prod.setIcon(QtGui.QIcon('update.png')) self.gear_btn=QPushButton() self.gear_btn.setIcon(QtGui.QIcon('gear.png')) hbox.addWidget(namelabel) hbox.addWidget(self.farm_combo) hbox.addWidget(self.shop_title_label) hbox.addWidget(self.btn_show_prod) # hbox.addWidget(self.gear_btn) self.date_combo=QComboBox() self.init_date_combo() self.btn_download=QPushButton("금일 데이터 받기") self.btn_download.setIcon(QtGui.QIcon("download.png")) hbox2.addWidget(QLabel("조회일")) hbox2.addWidget(self.date_combo) hbox2.addWidget(self.btn_download) hbox2.addStretch() self.gear_btn.clicked.connect(partial(self.setFarm,self.li)) self.btn_show_prod.clicked.connect(self.get_prod) self.farm_combo.currentTextChanged.connect(self.show_farm_name) self.btn_download.clicked.connect(self.download_data) vbox=QVBoxLayout() self.tablewidget=QTableWidget() self.updateProdList() self.groupbox=QGroupBox() self.groupbox2=QGroupBox() self.groupbox.setLayout(hbox) self.groupbox2.setLayout(hbox2) vbox.addWidget(self.groupbox) vbox.addWidget(self.groupbox2) self.tablewidget.resizeColumnToContents(0) vbox.addWidget(self.tablewidget) self.setLayout(vbox) def download_data(self): # mall_name='헤이해나' mall_name=self.shop_title_label.text() url_home=self.farm_combo.currentText() # req=requests.get(url) # soup=BeautifulSoup(req.text, 'html.parser') # self.shop_title_label.setText(soup.find('title').text.strip()) itemslist=all_items(mall_name, url_home) # print(itemslist) conn=sqlite3.connect('emaildb.sqlite') cur=conn.cursor() tod=datetime.today()+timedelta(days=0) tod=tod.strftime('%Y-%m-%d') url_home=self.farm_combo.currentText() # print(tod) for item in itemslist: #update link item['link']=url_home+'/products/'+item['pid'] # link=url_home="https://smartstore.naver.com/heyhannah/products/" +pid # print(item['name']) sql=f"REPLACE INTO PROD3 (dt,title, pid,jjim, sold,review,link) VALUES('{tod}','{item['name']}','{item['pid']}','{item['jjim']}','{item['sold']}','{item['review']}','{item['link']}')" # print(sql) cur.execute(sql) # cur.execute(''' # REPLACE INTO PROD3 (dt,title, pid,jjim, sold,review,link) VALUES (?,?,?,?,?,?,?);''', (tod,item['name'],item['pid'],item['jjim'],item['sold'],item['review'])) conn.commit() conn.commit() cur.close() conn.close() self.init_date_combo() self.updateProdList() def init_date_combo(self): mall_url=self.farm_combo.currentText() conn=sqlite3.connect('emaildb.sqlite') cur=conn.cursor() # tod=datetime.today().strftime('%Y-%m-%d') # for item in itemslist: # cur.execute(''' # REPlACE INTO PROD (dt,title, pid, jjim, sold,review) VALUES (?,?,?,?,?,?);''', (tod,item['name'],item['pid'] ,item['jjim'],item['sold'],item['review'])) sql=f"Select distinct dt from PROD3 where link like '{mall_url}%'" cur.execute(sql) conn.commit() rows=cur.fetchall() li=[] for row in rows: li.append(row[0]) # tod=datetime.today().strftime('%Y-%m-%d') # if tod not in li: # li.append(tod) li.sort(reverse=True) self.date_combo.clear() self.date_combo.addItems(li) # rs=self.updateProdList() # print(rs) cur.close() conn.close() # print(li) def updateProdList(self): self.tablewidget.clear() self.tablewidget.setRowCount(300) self.tablewidget.setColumnCount(6) self.tablewidget.setItem(0,0,QTableWidgetItem("상품명")) self.tablewidget.setItem(0,1,QTableWidgetItem("찜")) self.tablewidget.setItem(0,2,QTableWidgetItem("구매")) self.tablewidget.setItem(0,3,QTableWidgetItem("리뷰")) self.tablewidget.setItem(0,4,QTableWidgetItem("LINK")) # itemslist=all_items() conn=sqlite3.connect('emaildb.sqlite') cur=conn.cursor() # tod=datetime.today().strftime('%Y-%m-%d') tod=self.date_combo.currentText() mall_url=self.farm_combo.currentText() # for item in itemslist: # cur.execute(''' # REPlACE INTO PROD (dt,title, pid, jjim, sold,review) VALUES (?,?,?,?,?,?);''', (tod,item['name'],item['pid'] ,item['jjim'],item['sold'],item['review'])) # cur.execute(''' # Select title, jjim, sold, review from PROD3 where dt='2020-04-14' order by sold desc ''') # sql=f"Select title, jjim, sold, review,link from PROD3 where dt='{tod}' and link like '{self.farm_combo.currentText()}%'order by sold desc" sql=f"Select title, jjim, sold, review,link from PROD3 where dt='{tod}' and link like '{mall_url}%' order by sold desc" # print(sql) cur.execute(sql) conn.commit() rows=cur.fetchall() # print(rows[0]) for i,row in enumerate(rows): # print(i, row[0]) for j, elem in enumerate(row): # print(i+1,j,elem) # self.tablewidget.setItem(i+1,j,QTableWidgetItem(elem)) self.tablewidget.setItem(i+1,j,QTableWidgetItem(str(row[j]))) # print(row[1]) # self.tablewidget.setItem(i+1,1,QTableWidgetItem(str(row[1]))) self.tablewidget.resizeColumnToContents(0) cur.close() conn.close() return len(rows) def get_prod(self): url=self.farm_combo.currentText() dt=self.date_combo.currentText() self.tablewidget.clear() self.updateProdList() # print(url) def setFarm(self,li): self.farmlist=FarmList(self.li) # print(self.li) # self.farm_combo.addItems(self.li) self.farmlist.show() def show_farm_name(self): '''스토어팜 주소를 콤보박스에서 변경시에 검색하여 스토어팜 이름 표시 date_combo도 변경함 ''' # self.shop_title_label.setText("sssss") url=self.farm_combo.currentText() req=requests.get(url) soup=BeautifulSoup(req.text, 'html.parser') self.shop_title_label.setText(soup.find('title').text.strip())
class Example(QWidget): def __init__(self): super().__init__() self.hightingColor = QColor(255, 202, 0) self.blueColor = QColor(0, 186, 255) self.greenColor = QColor(0, 147, 44) self.redColor = QColor(255, 0, 0) self.setGeometry(100, 100, 1250, 800) self.setWindowTitle('宝大爷神器') self.show() self.mainUI() self.getUserInfo() # self.clearUI() # self.loginUI() def mainUI(self): self.box = QVBoxLayout() self.box.setSpacing(5) self.setLayout(self.box) def dataUI(self): self.box1 = QHBoxLayout() self.code = QLabel('股票代码') self.box1.addWidget(self.code) self.codeEdit = QLineEdit() self.codeEdit.setText('600519') self.box1.addWidget(self.codeEdit) self.year = QLabel('回报年限') self.yearEdit = QComboBox() for i in yearArr: self.yearEdit.addItem(str(i)) self.yearEdit.setCurrentIndex(5) self.box1.addWidget(self.year) self.box1.addWidget(self.yearEdit) # 同行年限 self.peerYear = QLabel('同行年限') self.peerYearEdit = QComboBox() for i in yearArr: self.peerYearEdit.addItem(str(i)) self.peerYearEdit.setCurrentIndex(2) self.box1.addWidget(self.peerYear) self.box1.addWidget(self.peerYearEdit) #开始日期 self.date = QLabel('开始日期') self.box1.addWidget(self.date) self.dateEdit = QDateEdit(QDate.currentDate().addDays(-365 * 10), self) self.dateEdit.setCalendarPopup(True) self.dateEdit.setDisplayFormat("yyyy-MM-dd") self.box1.addWidget(self.dateEdit) #结束日期 self.dateEnd = QLabel('结束日期') self.box1.addWidget(self.dateEnd) self.dateEditEnd = QDateEdit(QDate.currentDate(), self) self.dateEditEnd.setCalendarPopup(True) self.dateEditEnd.setDisplayFormat("yyyy-MM-dd") self.box1.addWidget(self.dateEditEnd) self.searchButton = QPushButton("估值") self.searchButton.clicked.connect(self.searchEvent) self.box1.addWidget(self.searchButton) self.peerButton = QPushButton("同行对比") self.peerButton.clicked.connect(self.searchPeerEvent) self.box1.addWidget(self.peerButton) self.box.addLayout(self.box1) self.box2 = QHBoxLayout() self.tips = QLabel('例子:以逗号隔开(000123,000333,000345)') self.box2.addWidget(self.tips) self.stockInfo = QLabel('') self.box2.addWidget(self.stockInfo) self.box.addLayout(self.box2) self.table = QTableWidget(30, 15) self.table.setStyleSheet( "QHeaderView::section {background-color:#f3f3f3;color: black;padding-left: 4px;border: 1px dotted #dddddd;}" ) # 设置表头字体,颜色,模式 self.box.addWidget(self.table) self.tipsUI() def loginUI(self): self.username = QLabel('账号') self.usernameEdit = QLineEdit() self.password = QLabel('密码') self.passwordEidt = QLineEdit() self.okButton = QPushButton("登录") self.grid = QGridLayout() self.grid.addWidget(self.username, 1, 0) self.grid.addWidget(self.usernameEdit, 1, 1) self.grid.addWidget(self.password, 2, 0) self.grid.addWidget(self.passwordEidt, 2, 1) self.grid.addWidget(self.okButton, 3, 1) self.box.addLayout(self.grid) self.okButton.clicked.connect(self.loginEvent) def tipsUI(self): self.boxTips = QVBoxLayout() self.boxTips.setSpacing(3) self.box.addLayout(self.boxTips) tipsData = [ '估值方法:', '小熊基本值=5年自由现金流之和/5年资本开支之和', '回本年限默认10年,N=10+护城河(-1/0/1/2)+成长性(-1/0/1/2)', '十年EBIT增长=(2003年EBIT-2012年EBIT)/2012年EBIT', '有形资本汇报率ROIC=(净利润+税+利息)/(流动资产+固定资产+在建工程)=税前息利润EBIT/有形资产合计----------- >15%', '理杏仁中的ROTA对应长投的ROIC,有形资产比他更加详细', 'EV/EQ=(总市值+有息负债-多余现金)/(流动资产+固定资产)=(总市值+有息负债-多余现金)/有形资产合计, EV/EQ=回报年限*ROIC', 'EV=总市值+有息负债-多余现金', '总市值:红色为高估,绿色为低估' ] for item in tipsData: self.boxTips.addWidget(QLabel(item)) def tableUI(self, jsonData): self.table.clear() colData = [{ 'label': '财务费用(累计)', 'value': 'profitStatement-fe' }, { 'label': '利润总额(累计)', 'value': 'profitStatement-tp' }, { 'label': '流动资产合计(累计)', 'value': 'balanceSheet-tca' }, { 'label': '固定资产(累计)', 'value': 'balanceSheet-fa' }, { 'label': '在建工程(累计)', 'value': 'balanceSheet-cip' }, { 'label': 'EBIT', }, { 'label': '有形资产合计', }, { 'label': 'ROIC', }, { 'label': 'EBIT同比增长率', }, { 'label': '经营活动产生的现金流量净额(累计)', 'value': 'cashFlow-ncffoa' }, { 'label': '自由现金流量(累计)', 'value': 'metrics-fcf' }, { 'label': '资本开支', }, { 'label': '货币资金(累计)', 'value': 'balanceSheet-cabb' }, { 'label': '有息负债(累计)', 'value': 'balanceSheet-lwi' }, { 'label': '小熊基本值', }, { 'label': '十年EBIT增长', }, { 'label': 'ROIC平均值', }, { 'label': '回报年限', }, { 'label': 'EQ=有形资产合计', }, { 'label': 'EV=EQ*(回本年限*ROIC)', }, { 'label': '估值总市值', }, { 'label': '当前总市值', }, { 'label': '当前每股股价', }, { 'label': '总股本', }, { 'label': '估值每股股价', }] stockData = [] print(222222, jsonData) for item in jsonData['fsMetricsList']: stockData.append(item) tableHeader = [] # 表头名字数据 tableColData = [] # 表列名字 self.table.setColumnCount(len(stockData)) self.table.setRowCount(len(colData)) print('roic数据的长度', len(stockData)) for index, item in enumerate(stockData): tableHeader.append(item['date'].split('T')[0]) self.table.setColumnWidth(index, 170) data = item['y'] for jIndex, jItem in enumerate(colData): if ('value' in jItem): attr = jItem['value'].split('-') newItem = QTableWidgetItem( str(data[attr[0]].get(attr[1], {'t': 0})['t'])) self.table.setItem(jIndex, index, newItem) item[attr[1]] = data[attr[0]].get( attr[1], {'t': 0})['t'] # 赋值最简值到该元素,方便后续的计算 elif jItem['label'] == 'EBIT': # EBIT = 财务费用+利润总额 newItem = QTableWidgetItem('{:.2f}'.format(item['fe'] + item['tp'])) newItem.setBackground(self.hightingColor) self.table.setItem(jIndex, index, newItem) item['EBIT'] = item['fe'] + item['tp'] elif jItem['label'] == '有形资产合计': # 有形资产合计 = 流动资产合计+固定资产+在建工程 newItem = QTableWidgetItem( '{:.2f}'.format(item['tca'] + item['fa'] + item['cip'])) newItem.setBackground(self.hightingColor) self.table.setItem(jIndex, index, newItem) item['EQ'] = item['tca'] + item['fa'] + item['cip'] elif jItem['label'] == 'ROIC': # ROIC = EBIT/有形资产合计 newItem = QTableWidgetItem( str('{:.2%}'.format(item['EBIT'] / item['EQ']))) newItem.setBackground(self.hightingColor) self.table.setItem(jIndex, index, newItem) item['ROIC'] = item['EBIT'] / item['EQ'] elif jItem['label'] == 'EBIT同比增长率': if index != 0: ebit = (stockData[index - 1]['EBIT'] - item['EBIT']) / item['EBIT'] newItem = QTableWidgetItem('{:.2%}'.format(ebit)) newItem.setBackground(self.hightingColor) self.table.setItem(jIndex, index - 1, newItem) elif jItem['label'] == '资本开支': # 资本开支 = 经营活动产生的现金流量净额-自由现金流量 newItem = QTableWidgetItem( str(item['ncffoa'] - item['fcf'])) newItem.setBackground(self.hightingColor) self.table.setItem(jIndex, index, newItem) item['CAPEX'] = item['ncffoa'] + item['fcf'] calData = self.getCalData(stockData) for index, item in enumerate(colData): tableColData.append(item['label']) if item['label'] == '小熊基本值': newItem = QTableWidgetItem(calData['BaseValue']) newItem.setBackground(self.blueColor) self.table.setItem(index, 0, newItem) elif item['label'] == '十年EBIT增长': stockLen = len(stockData) EBITValue = (stockData[0]['EBIT'] - stockData[stockLen - 1]['EBIT']) / \ stockData[stockLen - 1]['EBIT'] newItem = QTableWidgetItem( str('{:.2f}'.format(EBITValue)) + '倍') newItem.setBackground(self.blueColor) self.table.setItem(index, 0, newItem) elif item['label'] == 'ROIC平均值': newItem = QTableWidgetItem(calData['ROICAVG']) newItem.setBackground(self.blueColor) self.table.setItem(index, 0, newItem) elif item['label'] == 'EQ=有形资产合计': newItem = QTableWidgetItem(str(calData['EQ'])) newItem.setBackground(self.blueColor) self.table.setItem(index, 0, newItem) elif item['label'] == '回报年限': newItem = QTableWidgetItem(self.yearEdit.currentText()) newItem.setForeground(QBrush(QColor(255, 0, 0))) self.table.setItem(index, 0, newItem) elif item['label'] == 'EV=EQ*(回本年限*ROIC)': yearRoic = int(self.yearEdit.currentText()) * float( calData['ROICAVG'].strip('%')) / 100 global EV EV = calData['EQ'] * yearRoic newItem = QTableWidgetItem('{:.0f}'.format(EV)) newItem.setBackground(self.blueColor) self.table.setItem(index, 0, newItem) elif item['label'] == '估值总市值': price = EV - calData['lwi'] + calData['cabb'] self.price_pre = price newItem = QTableWidgetItem('{:.0f}'.format(price)) if price < calData['mc']: newItem.setBackground(self.redColor) else: newItem.setBackground(self.greenColor) self.table.setItem(index, 0, newItem) elif item['label'] == '当前总市值': price = calData['mc'] newItem = QTableWidgetItem(str(price)) self.table.setItem(index, 0, newItem) elif item['label'] == '当前每股股价': price = self.price_sp newItem = QTableWidgetItem(str(price)) self.table.setItem(index, 0, newItem) elif item['label'] == '总股本': price = self.price_num newItem = QTableWidgetItem(str(price)) self.table.setItem(index, 0, newItem) elif item['label'] == '估值每股股价': price = self.price_pre / self.price_num newItem = QTableWidgetItem(str(price)) self.table.setItem(index, 0, newItem) print(tableColData) print(tableHeader) self.table.setHorizontalHeaderLabels(tableHeader) # 设置表头数据 self.table.setVerticalHeaderLabels(tableColData) # 设置表列数据 # 同行对比表格 def peerTable(self, jsonData, stockIdArr): self.table.clear() colData = [] stockData = {} for item in jsonData['fsMetricsList']: id = item['stockId'] if (id in stockData): stockData[id].append(item) else: stockData[id] = [] stockData[id].append(item) tableHeader = [] # 表头名字数据 tableColData = [] # 表列名字 # 遍历股票代码数组,同行对比 idStrArr = self.stockIdArr #遍历行表头 start colData.append({'label': '归属母公司加权ROE'}) for jItem in idStrArr: colData.append({ 'label': self.stockNameData[jItem], 'value': 'ROE', 'id': int(jItem) }) colData.append({ 'label': str(len(idStrArr)) + '家均值', 'value': 'avg', 'type': 'ROE' }) colData.append({'label': '归属母公司扣非ROE'}) for jItem in idStrArr: colData.append({ 'label': self.stockNameData[jItem], 'value': 'ROE_A', 'id': int(jItem) }) colData.append({ 'label': str(len(idStrArr)) + '家均值', 'value': 'avg', 'type': 'ROE_A' }) colData.append({'label': 'ROIC'}) for jItem in idStrArr: colData.append({ 'label': self.stockNameData[jItem], 'value': 'ROIC', 'id': int(jItem) }) colData.append({ 'label': str(len(idStrArr)) + '家均值', 'value': 'avg', 'type': 'ROIC' }) colData.append({'label': '毛利率GM'}) for jItem in idStrArr: colData.append({ 'label': self.stockNameData[jItem], 'value': 'GM', 'id': int(jItem) }) colData.append({ 'label': str(len(idStrArr)) + '家均值', 'value': 'avg', 'type': 'GM' }) colData.append({'label': '净营业周期'}) for jItem in idStrArr: colData.append({ 'label': self.stockNameData[jItem], 'value': 'ROUND', 'id': int(jItem) }) colData.append({ 'label': str(len(idStrArr)) + '家均值', 'value': 'avg', 'type': 'ROUND' }) colData.append({'label': '三费占比'}) for jItem in idStrArr: colData.append({ 'label': self.stockNameData[jItem], 'value': 'FEE', 'id': int(jItem) }) colData.append({ 'label': str(len(idStrArr)) + '家均值', 'value': 'avg', 'type': 'FEE' }) # 遍历行表头 end # 遍历表列名 for index, item in enumerate(colData): tableColData.append(item['label']) #找出行业数据中长度最小的,以防下面遍历出错 stockDataLen = [] for key in stockData: stockDataLen.append(len(stockData[key])) stockDataLen.sort() print('找出行业数据中长度最小的,以防下面遍历出错%s' % stockDataLen[0]) # 平均值对象 avgData = { 'ROE': [], 'ROE_A': [], 'ROIC': [], 'GM': [], 'ROUND': [], 'FEE': [] } year = int(self.peerYearEdit.currentText()) tablePerDataLen = stockDataLen[0] - 1 > year and year or stockDataLen[ 0] - 1 # 净营业周期需要计算期初和期末,len-1 print('同行对比年数:', tablePerDataLen) self.table.setColumnCount(tablePerDataLen + 1) self.table.setRowCount(len(colData)) # 遍历表头,遍历表格内容, for index in range(tablePerDataLen): tableHeader.append( stockData[stockIdArr[0]][index]['date'].split('T')[0]) self.table.setColumnWidth(index, 100) for jIndex, jItem in enumerate(colData): color = self.blueColor if 'value' in jItem: dItem = 'id' in jItem and stockData[jItem['id']] or {} d = '' if jItem['value'] == 'ROE': d = dItem[index]['y']['metrics'].get('wroe', {'t': 0})['t'] d = '{:.2%}'.format(d) dItem[index]['ROE'] = d elif jItem['value'] == 'ROE_A': d = dItem[index]['y']['metrics'].get( 'roe_adnrpatoshaopc', {'t': 0})['t'] d = '{:.2%}'.format(d) dItem[index]['ROE_A'] = d elif jItem['value'] == 'ROIC': d = dItem[index]['y']['metrics'].get('rota', {'t': 0})['t'] d = '{:.2%}'.format(d) dItem[index]['ROIC'] = d elif jItem['value'] == 'GM': d = dItem[index]['y']['profitStatement']['gp_m']['t'] d = '{:.2%}'.format(d) dItem[index]['GM'] = d elif jItem['value'] == 'ROUND': # 净营业周期=存货周转天数+应收账款周转天数-应付账款周转天数 # 应收账款周转天数 arAvg = (dItem[index]['y']['balanceSheet']['ar']['t'] + dItem[index + 1]['y']['balanceSheet']['ar']['t']) / 2 ar = arAvg > 0 and 360 / ( stockData[jItem['id']][index]['y'] ['profitStatement']['oi']['t'] / arAvg) or 0 # 应付账款周转天数 apAvg = (dItem[index]['y']['balanceSheet']['ap']['t'] + dItem[index + 1]['y']['balanceSheet']['ap']['t']) / 2 ap = apAvg > 0 and 360 / ( stockData[jItem['id']][index]['y'] ['profitStatement']['oc']['t'] / apAvg) or 0 i_ds = stockData[ jItem['id']][index]['y']['metrics']['i_ds']['t'] d = i_ds + ar - ap d = '{:.2f}'.format(d) dItem[index]['ROUND'] = d print(i_ds, ar, ap) elif jItem['value'] == 'FEE': d = stockData[jItem['id']][index]['y'][ 'profitStatement']['te_r']['t'] d = '{:.2%}'.format(d) dItem[index]['FEE'] = d elif jItem['value'] == 'avg': #平均值 count = 0 for key in stockData: v = stockData[key][index][jItem['type']] vfloat = float('%' in v and v.strip('%') or v) count += vfloat d = count / len(stockData) d = '%' in v and '{:.2%}'.format( d / 100) or '{:.2f}'.format(d) avgData[jItem['type']].append(d) color = self.hightingColor newItem = QTableWidgetItem(str(d)) newItem.setBackground(color) self.table.setItem(jIndex, index, newItem) #每一行求平均值 tableHeader.append('平均值') for jIndex, jItem in enumerate(colData): if 'value' in jItem: d = 0 color = self.greenColor for index in range(tablePerDataLen): if jItem['value'] == 'avg': # 平均值 v = avgData[jItem['type']][index] else: v = stockData[jItem['id']][index][jItem['value']] vfloat = float('%' in v and v.strip('%') or v) d += vfloat d = d / tablePerDataLen d = '%' in v and '{:.2%}'.format(d / 100) or '{:.2f}'.format(d) newItem = QTableWidgetItem(str(d)) newItem.setBackground(color) self.table.setItem(jIndex, tablePerDataLen, newItem) self.table.setHorizontalHeaderLabels(tableHeader) # 设置表头数据 self.table.setVerticalHeaderLabels(tableColData) # 设置表列数据 # 获取统计数据 def getCalData(self, data): CAPEXSum = 0 # 5年资本开支之和 FCFSum = 0 # 5年自由现金流之和 ROICAVG = 0 # roic平均值 EQ = data[0]['EQ'] # 有形资产合计 lwi = data[0]['lwi'] # 有息负债 cabb = data[0]['cabb'] # 货币资金--多余现金 mc = self.price_mc # 总市值 for jIndex, jItem in enumerate(data): if (jIndex < 5): CAPEXSum += jItem['CAPEX'] FCFSum += jItem['fcf'] ROICAVG += jItem['ROIC'] return { 'BaseValue': '{:.2}'.format(FCFSum / CAPEXSum), 'ROICAVG': '{:.2%}'.format(ROICAVG / len(data)), 'EQ': EQ, 'lwi': lwi, 'cabb': cabb, 'mc': mc } def clearUI(self): for i in range(self.box.count()): boxChild = self.box.itemAt(i) for j in range(boxChild.count()): boxChild.itemAt(j).widget().deleteLater() def getUserInfo(self): self.clearUI() res = requests.get("https://www.lixinger.com/api/user/users/current", headers=Headers) if res.status_code == 200: self.dataUI() else: self.loginUI() def loginEvent(self): data = { 'uniqueName': self.usernameEdit.text(), 'password': self.passwordEidt.text() } # 用户信息 res = requests.post("https://www.lixinger.com/api/login/by-account", data) if res.status_code == 200: m_cookie = res.headers["Set-Cookie"].split(';')[0] Headers["Cookie"] = m_cookie f = open(cookieFilename, 'w') f.write(m_cookie) print(Headers["Cookie"]) self.getUserInfo() else: print("登录连接不成功%s" % (res.status_code)) # 查询按钮事件 def searchEvent(self, type): self.getStockInfo() self.getROICData() def searchPeerEvent(self, type): self.getStockInfo() self.getPeerData() # 获取股票的详细信息 def getStockInfo(self): arr = self.codeEdit.text().split(',') self.stockIdArr = [] detailStr = '' noSearchId = [] self.stockNameData = {} for item in arr: url = 'https://www.lixinger.com/api/stock/stocks/stock/' if '60' == item[0:2]: url += 'sh/' + item + '/' + item else: url += 'sz/' + item + '/' + item res = requests.get(url, headers=Headers) if res.status_code == 200: data = json.loads(res.text) self.stockIdArr.append(item) detailStr += item + ': ' + data['name'] + ' ' self.stockNameData[item] = data['name'] self.price_mc = data['priceMetrics']['mc'] #当前总市值 self.price_sp = data['priceMetrics']['sp'] #每股股价 self.price_num = data['priceMetrics']['mc'] / data[ 'priceMetrics']['sp'] #股本 elif res.status_code == 401: self.loginEvent() else: print('没有' + item + '股票') noSearchId.append(item) print(noSearchId) if len(noSearchId) > 0: noSearchStr = ','.join(noSearchId) detailStr += '(没有找到股票:' + noSearchStr + ')' self.stockInfo.setText(detailStr) print(self.stockNameData) print(self.stockIdArr) # 获取roic数据 def getROICData(self): if len(self.stockIdArr) > 0: print(self.dateEdit.text(), self.dateEditEnd.text()) p = { "stockIds": [int(self.stockIdArr[0])], "startDate": self.dateEdit.text(), "endDate": self.dateEditEnd.text(), "granularities": ["y"], "metricNames": [ "profitStatement.fe", "profitStatement.tp", "balanceSheet.tca", "balanceSheet.fa", "balanceSheet.cip", "balanceSheet.cabb", "balanceSheet.lwi", "cashFlow.ncffoa", "metrics.fcf" ], "expressionCaculateTypes": [ "t", "t_o", "t_y2y", "t_c2c", "c", "c_o", "c_y2y", "c_c2c", "c_2y", "ttm", "ttm_y2y", "ttm_c2c" ] } r = requests.post( 'https://www.lixinger.com/api/analyt/company/fs-metrics/list-info', json=p, headers=Headers) if r.status_code == 200: self.tableUI(json.loads(r.text)) elif r.status_code == 401: self.loginEvent() # 获取同行数据 def getPeerData(self): idsArr = [] time = datetime.datetime.strptime(self.dateEdit.text(), "%Y-%m-%d").date() dateStart = time + datetime.timedelta(days=-365) for val in self.stockIdArr: idsArr.append(int(val)) p = { "stockIds": idsArr, "startDate": str(dateStart), "endDate": self.dateEditEnd.text(), "granularities": ["y"], "metricNames": [ "profitStatement.gp_m", "profitStatement.te_r", "profitStatement.oi", "profitStatement.oc", "metrics.wroe", "metrics.roe_adnrpatoshaopc", "metrics.rota", "metrics.i_ds", "balanceSheet.ar", "balanceSheet.ap" ], "expressionCaculateTypes": [ "t", "t_o", "t_y2y", "t_c2c", "c", "c_o", "c_y2y", "c_c2c", "c_2y", "ttm", "ttm_y2y", "ttm_c2c" ] } r = requests.post( 'https://www.lixinger.com/api/analyt/company/fs-metrics/list-info', json=p, headers=Headers) if r.status_code == 200: self.peerTable(json.loads(r.text), idsArr) elif r.status_code == 401: self.loginEvent()
class OWdabam_height_profile(OWWidget): name = "DABAM Height Profile" id = "dabam_height_profile" description = "Calculation of mirror surface error profile" icon = "icons/dabam.png" author = "Luca Rebuffi" maintainer_email = "[email protected]; [email protected]" priority = 2 category = "" keywords = ["dabam_height_profile"] outputs = [{ "name": "PreInput", "type": WiserPreInputData, "doc": "PreInput", "id": "PreInput" }] want_main_area = 1 want_control_area = 1 MAX_WIDTH = 1320 MAX_HEIGHT = 700 IMAGE_WIDTH = 860 IMAGE_HEIGHT = 645 CONTROL_AREA_WIDTH = 405 TABS_AREA_HEIGHT = 618 xx = None yy = None entry_number = Setting(1) shape = Setting(0) slope_error_from = Setting(0.0) slope_error_to = Setting(1.5) dimension_y_from = Setting(0.0) dimension_y_to = Setting(200.0) use_undetrended = Setting(0) center_y = Setting(1) modify_y = Setting(0) new_length = Setting(200.0) filler_value = Setting(0.0) renormalize_y = Setting(1) error_type_y = Setting(0) rms_y = Setting(0.9) dabam_profile_index = Setting(1) heigth_profile_file_name = Setting('mirror.dat') tab = [] def __init__(self): super().__init__() self.runaction = widget.OWAction("Calculate Height Profile", self) self.runaction.triggered.connect(self.calculate_heigth_profile_ni) self.addAction(self.runaction) self.runaction = widget.OWAction("Generate Height Profile File", self) self.runaction.triggered.connect(self.generate_heigth_profile_file_ni) self.addAction(self.runaction) geom = QApplication.desktop().availableGeometry() self.setGeometry( QRect(round(geom.width() * 0.05), round(geom.height() * 0.05), round(min(geom.width() * 0.98, self.MAX_WIDTH)), round(min(geom.height() * 0.95, self.MAX_HEIGHT)))) self.setMaximumHeight(self.geometry().height()) self.setMaximumWidth(self.geometry().width()) # DABAM INITIALIZATION self.server = dabam.dabam() self.server.set_input_silent(True) gui.separator(self.controlArea) button_box = oasysgui.widgetBox(self.controlArea, "", addSpace=False, orientation="horizontal") button = gui.button(button_box, self, "Calculate Height\nProfile", callback=self.calculate_heigth_profile) button.setFixedHeight(45) button = gui.button(button_box, self, "Generate Height\nProfile File", callback=self.generate_heigth_profile_file) font = QFont(button.font()) font.setBold(True) button.setFont(font) palette = QPalette(button.palette()) # make a copy of the palette palette.setColor(QPalette.ButtonText, QColor('Dark Blue')) button.setPalette(palette) # assign new palette button.setFixedHeight(45) button.setFixedWidth(150) button = gui.button(button_box, self, "Reset Fields", callback=self.call_reset_settings) font = QFont(button.font()) font.setItalic(True) button.setFont(font) palette = QPalette(button.palette()) # make a copy of the palette palette.setColor(QPalette.ButtonText, QColor('Dark Red')) button.setPalette(palette) # assign new palette button.setFixedHeight(45) gui.separator(self.controlArea) tabs_setting = oasysgui.tabWidget(self.controlArea) tabs_setting.setFixedHeight(self.TABS_AREA_HEIGHT) tabs_setting.setFixedWidth(self.CONTROL_AREA_WIDTH - 5) tab_input = oasysgui.createTabPage(tabs_setting, "DABAM Search Setting") tab_gener = oasysgui.createTabPage(tabs_setting, "DABAM Generation Setting") tab_out = oasysgui.createTabPage(tabs_setting, "Output") manual_box = oasysgui.widgetBox(tab_input, "Manual Entry", addSpace=True, orientation="vertical") oasysgui.lineEdit(manual_box, self, "entry_number", "Entry Number", labelWidth=300, valueType=int, orientation="horizontal") gui.separator(manual_box) button = gui.button(manual_box, self, "Retrieve Profile", callback=self.retrieve_profile) button.setFixedHeight(35) button.setFixedWidth(self.CONTROL_AREA_WIDTH - 35) input_box = oasysgui.widgetBox(tab_input, "Search Parameters", addSpace=True, orientation="vertical") gui.comboBox(input_box, self, "shape", label="Mirror Shape", labelWidth=300, items=[ "All", "Plane", "Cylindrical", "Elliptical", "Toroidal", "Spherical" ], sendSelectedValue=False, orientation="horizontal") gui.separator(input_box) input_box_1 = oasysgui.widgetBox(input_box, "", addSpace=True, orientation="horizontal") oasysgui.lineEdit(input_box_1, self, "slope_error_from", "Slope Error From (" + u"\u03BC" + "rad)", labelWidth=150, valueType=float, orientation="horizontal") oasysgui.lineEdit(input_box_1, self, "slope_error_to", "To (" + u"\u03BC" + "rad)", labelWidth=60, valueType=float, orientation="horizontal") input_box_2 = oasysgui.widgetBox(input_box, "", addSpace=True, orientation="horizontal") self.le_dimension_y_from = oasysgui.lineEdit(input_box_2, self, "dimension_y_from", "Mirror Length From", labelWidth=150, valueType=float, orientation="horizontal") self.le_dimension_y_to = oasysgui.lineEdit(input_box_2, self, "dimension_y_to", "To", labelWidth=60, valueType=float, orientation="horizontal") table_box = oasysgui.widgetBox(tab_input, "Search Results", addSpace=True, orientation="vertical", height=250) self.overlay_search = Overlay(table_box, self.search_profiles) self.overlay_search.hide() button = gui.button(input_box, self, "Search", callback=self.overlay_search.show) button.setFixedHeight(35) button.setFixedWidth(self.CONTROL_AREA_WIDTH - 35) gui.comboBox(table_box, self, "use_undetrended", label="Use Undetrended Profile", labelWidth=300, items=["No", "Yes"], callback=self.table_item_clicked, sendSelectedValue=False, orientation="horizontal") gui.separator(table_box) self.scrollarea = QScrollArea() self.scrollarea.setMinimumWidth(self.CONTROL_AREA_WIDTH - 35) table_box.layout().addWidget(self.scrollarea, alignment=Qt.AlignHCenter) self.table = QTableWidget(1, 5) self.table.setStyleSheet("background-color: #FBFBFB;") self.table.setAlternatingRowColors(True) self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed) self.table.verticalHeader().setVisible(False) self.table.setColumnWidth(0, 40) self.table.setColumnWidth(1, 70) self.table.setColumnWidth(2, 70) self.table.setColumnWidth(3, 85) self.table.setColumnWidth(4, 80) self.table.resizeRowsToContents() self.table.setSelectionBehavior(QAbstractItemView.SelectRows) self.table.itemClicked.connect(self.table_item_clicked) self.scrollarea.setWidget(self.table) self.scrollarea.setWidgetResizable(1) output_profile_box = oasysgui.widgetBox( tab_gener, "Surface Generation Parameters", addSpace=True, orientation="vertical", height=370) gui.comboBox(output_profile_box, self, "center_y", label="Center Profile in the middle of O.E.", labelWidth=300, items=["No", "Yes"], sendSelectedValue=False, orientation="horizontal") gui.separator(output_profile_box) gui.comboBox(output_profile_box, self, "modify_y", label="Modify Length?", labelWidth=150, items=[ "No", "Rescale to new length", "Fit to new length (fill or cut)" ], callback=self.set_ModifyY, sendSelectedValue=False, orientation="horizontal") self.modify_box_1 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=60) self.modify_box_2 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=60) self.le_new_length_1 = oasysgui.lineEdit(self.modify_box_2, self, "new_length", "New Length", labelWidth=300, valueType=float, orientation="horizontal") self.modify_box_3 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=60) self.le_new_length_2 = oasysgui.lineEdit(self.modify_box_3, self, "new_length", "New Length", labelWidth=300, valueType=float, orientation="horizontal") oasysgui.lineEdit(self.modify_box_3, self, "filler_value", "Filler Value (if new length > profile length) [nm]", labelWidth=300, valueType=float, orientation="horizontal") self.set_ModifyY() gui.comboBox(output_profile_box, self, "renormalize_y", label="Renormalize Length Profile to different RMS", labelWidth=300, items=["No", "Yes"], callback=self.set_RenormalizeY, sendSelectedValue=False, orientation="horizontal") self.output_profile_box_1 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=60) self.output_profile_box_2 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=60) gui.comboBox( self.output_profile_box_1, self, "error_type_y", label="Normalization to", labelWidth=270, items=["Figure Error (nm)", "Slope Error (" + u"\u03BC" + "rad)"], sendSelectedValue=False, orientation="horizontal") oasysgui.lineEdit(self.output_profile_box_1, self, "rms_y", "Rms Value", labelWidth=300, valueType=float, orientation="horizontal") self.set_RenormalizeY() output_box = oasysgui.widgetBox(tab_gener, "Outputs", addSpace=True, orientation="vertical") select_file_box = oasysgui.widgetBox(output_box, "", addSpace=True, orientation="horizontal") self.le_heigth_profile_file_name = oasysgui.lineEdit( select_file_box, self, "heigth_profile_file_name", "Output File Name", labelWidth=120, valueType=str, orientation="horizontal") gui.button(select_file_box, self, "...", callback=self.selectFile) self.shadow_output = oasysgui.textArea(height=400) out_box = oasysgui.widgetBox(tab_out, "System Output", addSpace=True, orientation="horizontal", height=500) out_box.layout().addWidget(self.shadow_output) gui.rubber(self.controlArea) self.initializeTabs() gui.rubber(self.mainArea) self.overlay_search.raise_() def resizeEvent(self, event): self.overlay_search.resize(self.CONTROL_AREA_WIDTH - 15, 290) event.accept() def after_change_workspace_units(self): self.si_to_user_units = 1e2 / self.workspace_units_to_cm self.horHeaders = [ "Entry", "Shape", "Length\n[" + self.workspace_units_label + "]", "Heights St.Dev.\n[nm]", "Slopes St.Dev.\n[" + u"\u03BC" + "rad]" ] self.table.setHorizontalHeaderLabels(self.horHeaders) self.plot_canvas[0].setGraphXLabel("Y [" + self.workspace_units_label + "]") self.plot_canvas[1].setGraphXLabel("Y [" + self.workspace_units_label + "]") self.plot_canvas[5].setGraphXLabel("Y [" + self.workspace_units_label + "]") label = self.le_dimension_y_from.parent().layout().itemAt(0).widget() label.setText(label.text() + " [" + self.workspace_units_label + "]") label = self.le_dimension_y_to.parent().layout().itemAt(0).widget() label.setText(label.text() + " [" + self.workspace_units_label + "]") label = self.le_new_length_1.parent().layout().itemAt(0).widget() label.setText(label.text() + " [" + self.workspace_units_label + "]") label = self.le_new_length_2.parent().layout().itemAt(0).widget() label.setText(label.text() + " [" + self.workspace_units_label + "]") def initializeTabs(self): self.tabs = oasysgui.tabWidget(self.mainArea) self.tab = [ oasysgui.createTabPage(self.tabs, "Info"), oasysgui.createTabPage(self.tabs, "Heights Profile"), oasysgui.createTabPage(self.tabs, "Slopes Profile"), oasysgui.createTabPage(self.tabs, "PSD Heights"), oasysgui.createTabPage(self.tabs, "CSD Heights"), oasysgui.createTabPage(self.tabs, "ACF"), oasysgui.createTabPage(self.tabs, "Generated 1D Profile"), ] for tab in self.tab: tab.setFixedHeight(self.IMAGE_HEIGHT) tab.setFixedWidth(self.IMAGE_WIDTH) self.plot_canvas = [None, None, None, None, None, None] self.plot_canvas[0] = oasysgui.plotWindow(roi=False, control=False, position=True) self.plot_canvas[0].setDefaultPlotLines(True) self.plot_canvas[0].setActiveCurveColor(color='blue') self.plot_canvas[0].setGraphYLabel("Z [nm]") self.plot_canvas[0].setGraphTitle("Heights Profile") self.plot_canvas[0].setInteractiveMode(mode='zoom') self.plot_canvas[1] = oasysgui.plotWindow(roi=False, control=False, position=True) self.plot_canvas[1].setDefaultPlotLines(True) self.plot_canvas[1].setActiveCurveColor(color='blue') self.plot_canvas[1].setGraphYLabel("Zp [$\mu$rad]") self.plot_canvas[1].setGraphTitle("Slopes Profile") self.plot_canvas[1].setInteractiveMode(mode='zoom') self.plot_canvas[2] = oasysgui.plotWindow(roi=False, control=False, position=True) self.plot_canvas[2].setDefaultPlotLines(True) self.plot_canvas[2].setActiveCurveColor(color='blue') self.plot_canvas[2].setGraphXLabel("f [m^-1]") self.plot_canvas[2].setGraphYLabel("PSD [m^3]") self.plot_canvas[2].setGraphTitle( "Power Spectral Density of Heights Profile") self.plot_canvas[2].setInteractiveMode(mode='zoom') self.plot_canvas[2].setXAxisLogarithmic(True) self.plot_canvas[2].setYAxisLogarithmic(True) self.plot_canvas[3] = oasysgui.plotWindow(roi=False, control=False, position=True) self.plot_canvas[3].setDefaultPlotLines(True) self.plot_canvas[3].setActiveCurveColor(color='blue') self.plot_canvas[3].setGraphXLabel("f [m^-1]") self.plot_canvas[3].setGraphYLabel("CSD [m^3]") self.plot_canvas[3].setGraphTitle( "Cumulative Spectral Density of Heights Profile") self.plot_canvas[3].setInteractiveMode(mode='zoom') self.plot_canvas[3].setXAxisLogarithmic(True) self.plot_canvas[4] = oasysgui.plotWindow(roi=False, control=False, position=True) self.plot_canvas[4].setDefaultPlotLines(True) self.plot_canvas[4].setActiveCurveColor(color='blue') self.plot_canvas[4].setGraphXLabel("Length [m]") self.plot_canvas[4].setGraphYLabel("ACF") self.plot_canvas[4].setGraphTitle( "Autocovariance Function of Heights Profile") self.plot_canvas[4].setInteractiveMode(mode='zoom') self.plot_canvas[5] = oasysgui.plotWindow(roi=False, control=False, position=True) self.plot_canvas[5].setDefaultPlotLines(True) self.plot_canvas[5].setActiveCurveColor(color='blue') self.plot_canvas[5].setGraphYLabel("Z [nm]") self.plot_canvas[5].setGraphTitle("Heights Profile") self.plot_canvas[5].setInteractiveMode(mode='zoom') self.profileInfo = oasysgui.textArea(height=self.IMAGE_HEIGHT - 5, width=400) profile_box = oasysgui.widgetBox(self.tab[0], "", addSpace=True, orientation="horizontal", height=self.IMAGE_HEIGHT, width=410) profile_box.layout().addWidget(self.profileInfo) for index in range(0, 6): self.tab[index + 1].layout().addWidget(self.plot_canvas[index]) self.tabs.setCurrentIndex(1) def plot_dabam_graph(self, plot_canvas_index, curve_name, x_values, y_values, xtitle, ytitle, title="", color='blue', replace=True): self.plot_canvas[plot_canvas_index].addCurve( x_values, y_values, curve_name, symbol='', color=color, replace=replace) #'+', '^', ',' self.plot_canvas[plot_canvas_index].setGraphTitle(title) self.plot_canvas[plot_canvas_index].setGraphXLabel(xtitle) self.plot_canvas[plot_canvas_index].setGraphYLabel(ytitle) self.plot_canvas[plot_canvas_index].replot() def set_ModifyY(self): self.modify_box_1.setVisible(self.modify_y == 0) self.modify_box_2.setVisible(self.modify_y == 1) self.modify_box_3.setVisible(self.modify_y == 2) def set_RenormalizeY(self): self.output_profile_box_1.setVisible(self.renormalize_y == 1) def table_item_clicked(self): if self.table.selectionModel().hasSelection(): if not self.table.rowCount() == 0: if not self.table.item(0, 0) is None: row = self.table.selectionModel().selectedRows()[0].row() self.entry_number = int(self.table.item(row, 0).text()) self.retrieve_profile() def retrieve_profile(self): try: if self.entry_number is None or self.entry_number <= 0: raise Exception( "Entry number should be a strictly positive integer number" ) self.server.load(self.entry_number) self.profileInfo.setText(self.server.info_profiles()) title0 = "Heights Profile. St.Dev.=%.3f nm" % ( self.server.stdev_profile_heights() * 1e9) title1 = "Slopes Profile. St.Dev.=%.3f $\mu$rad" % ( self.server.stdev_profile_slopes() * 1e6) if self.use_undetrended == 0: self.plot_dabam_graph(0, "heights_profile", self.si_to_user_units * self.server.y, 1e9 * self.server.zHeights, "Y [" + self.workspace_units_label + "]", "Z [nm]", title=title0) self.plot_dabam_graph(1, "slopes_profile", self.si_to_user_units * self.server.y, 1e6 * self.server.zSlopes, "Y [" + self.workspace_units_label + "]", "Zp [$\mu$rad]", title=title1) else: self.plot_dabam_graph(0, "heights_profile", self.si_to_user_units * self.server.y, 1e9 * self.server.zHeightsUndetrended, "Y [" + self.workspace_units_label + "]", "Z [nm]", title=title0) self.plot_dabam_graph(1, "slopes_profile", self.si_to_user_units * self.server.y, 1e6 * self.server.zSlopesUndetrended, "Y [" + self.workspace_units_label + "]", "Zp [$\mu$rad]", title=title1) y = self.server.f**(self.server.powerlaw["hgt_pendent"] ) * 10**self.server.powerlaw["hgt_shift"] i0 = self.server.powerlaw["index_from"] i1 = self.server.powerlaw["index_to"] beta = -self.server.powerlaw["hgt_pendent"] self.plot_dabam_graph( 2, "psd_heights_2", self.server.f, self.server.psdHeights, "f [m^-1]", "PSD [m^3]", title= "Power Spectral Density of Heights Profile (beta=%.2f,Df=%.2f)" % (beta, (5 - beta) / 2)) self.plot_dabam_graph(2, "psd_heights_1", self.server.f, y, "f [m^-1]", "PSD [m^3]", color='green', replace=False) self.plot_dabam_graph(2, "psd_heights_3", self.server.f[i0:i1], y[i0:i1], "f [m^-1]", "PSD [m^3]", color='red', replace=False) self.plot_dabam_graph(3, "csd", self.server.f, self.server.csd_heights(), "f [m^-1]", "CSD [m^3]") c1, c2, c3 = dabam.autocorrelationfunction(self.server.y, self.server.zHeights) self.plot_dabam_graph( 4, "acf", c1[0:-1], c2, "Length [m]", "Heights Autocovariance", title= "Autocovariance Function of Heights Profile.\nAutocorrelation Length (ACF=0.5)=%.3f m" % (c3)) # surface error removal if not self.yy is None and not self.xx is None: self.xx = None self.yy = None self.plot_dabam_graph(5, "heights_profile_generated", numpy.zeros(1), numpy.zeros(1), "Y [" + self.workspace_units_label + "]", "Z [nm]") if (self.tabs.currentIndex() == 6): self.tabs.setCurrentIndex(1) except Exception as exception: QMessageBox.critical(self, "Error", exception.args[0], QMessageBox.Ok) #raise exception def search_profiles(self): try: self.table.itemClicked.disconnect(self.table_item_clicked) self.table.clear() row_count = self.table.rowCount() for n in range(0, row_count): self.table.removeRow(0) self.table.setHorizontalHeaderLabels(self.horHeaders) profiles = dabam.dabam_summary_dictionary( surface=self.get_dabam_shape(), slp_err_from=self.slope_error_from * 1e-6, slp_err_to=self.slope_error_to * 1e-6, length_from=self.dimension_y_from / self.si_to_user_units, length_to=self.dimension_y_to / self.si_to_user_units) for index in range(0, len(profiles)): self.table.insertRow(0) for index in range(0, len(profiles)): table_item = QTableWidgetItem(str(profiles[index]["entry"])) table_item.setTextAlignment(Qt.AlignCenter) self.table.setItem(index, 0, table_item) table_item = QTableWidgetItem(str(profiles[index]["surface"])) table_item.setTextAlignment(Qt.AlignLeft) self.table.setItem(index, 1, table_item) table_item = QTableWidgetItem( str( numpy.round( profiles[index]["length"] * self.si_to_user_units, 3))) table_item.setTextAlignment(Qt.AlignRight) self.table.setItem(index, 2, table_item) table_item = QTableWidgetItem( str(numpy.round(profiles[index]["hgt_err"] * 1e9, 3))) table_item.setTextAlignment(Qt.AlignRight) self.table.setItem(index, 3, table_item) table_item = QTableWidgetItem( str(numpy.round(profiles[index]["slp_err"] * 1e6, 3))) table_item.setTextAlignment(Qt.AlignRight) self.table.setItem(index, 4, table_item) self.table.setHorizontalHeaderLabels(self.horHeaders) self.table.resizeRowsToContents() self.table.setSelectionBehavior(QAbstractItemView.SelectRows) self.table.itemClicked.connect(self.table_item_clicked) self.overlay_search.hide() except Exception as exception: self.overlay_search.hide() QMessageBox.critical(self, "Error", exception.args[0], QMessageBox.Ok) def get_dabam_shape(self): if self.shape == 0: return None elif self.shape == 1: return "plane" elif self.shape == 2: return "cylindrical" elif self.shape == 3: return "elliptical" elif self.shape == 4: return "toroidal" elif self.shape == 5: return "spherical" def calculate_heigth_profile_ni(self): self.calculate_heigth_profile(not_interactive_mode=True) def calculate_heigth_profile(self, not_interactive_mode=False): import matplotlib print(matplotlib.__version__) try: if self.server.y is None: raise Exception("No Profile Selected") sys.stdout = EmittingStream(textWritten=self.writeStdOut) self.check_fields() # PREVENTS CRASH WITH PYQT5 if not not_interactive_mode: self.tabs.setCurrentIndex(6) if self.modify_y == 2: profile_1D_y_x_temp = self.si_to_user_units * self.server.y if self.use_undetrended == 0: profile_1D_y_y_temp = self.si_to_user_units * self.server.zHeights else: profile_1D_y_y_temp = self.si_to_user_units * self.server.zHeightsUndetrended first_coord = profile_1D_y_x_temp[0] second_coord = profile_1D_y_x_temp[1] last_coord = profile_1D_y_x_temp[-1] step = numpy.abs(second_coord - first_coord) length = numpy.abs(last_coord - first_coord) n_points_old = len(profile_1D_y_x_temp) if self.new_length > length: difference = self.new_length - length n_added_points = int(difference / step) if difference % step == 0: n_added_points += 1 if n_added_points % 2 != 0: n_added_points += 1 profile_1D_y_x = numpy.arange(n_added_points + n_points_old) * step profile_1D_y_y = numpy.ones( n_added_points + n_points_old ) * self.filler_value * 1e-9 * self.si_to_user_units profile_1D_y_y[int(n_added_points / 2):n_points_old + int(n_added_points / 2)] = profile_1D_y_y_temp elif self.new_length < length: difference = length - self.new_length n_removed_points = int(difference / step) if difference % step == 0: n_removed_points -= 1 if n_removed_points % 2 != 0: n_removed_points -= 1 if n_removed_points >= 2: profile_1D_y_x = profile_1D_y_x_temp[0:( n_points_old - n_removed_points)] profile_1D_y_y = profile_1D_y_y_temp[( int(n_removed_points / 2) - 1):(n_points_old - int(n_removed_points / 2) - 1)] else: profile_1D_y_x = profile_1D_y_x_temp profile_1D_y_y = profile_1D_y_y_temp else: profile_1D_y_x = profile_1D_y_x_temp profile_1D_y_y = profile_1D_y_y_temp else: if self.modify_y == 0: profile_1D_y_x = self.si_to_user_units * self.server.y elif self.modify_y == 1: scale_factor_y = self.new_length / ( self.si_to_user_units * (max(self.server.y) - min(self.server.y))) profile_1D_y_x = self.si_to_user_units * self.server.y * scale_factor_y if self.use_undetrended == 0: profile_1D_y_y = self.si_to_user_units * self.server.zHeights else: profile_1D_y_y = self.si_to_user_units * self.server.zHeightsUndetrended if self.center_y: first_coord = profile_1D_y_x[0] last_coord = profile_1D_y_x[-1] length = numpy.abs(last_coord - first_coord) profile_1D_y_x_temp = numpy.linspace(-length / 2, length / 2, len(profile_1D_y_x)) profile_1D_y_x = profile_1D_y_x_temp if self.renormalize_y == 0: rms_y = None else: if self.error_type_y == profiles_simulation.FIGURE_ERROR: rms_y = self.si_to_user_units * self.rms_y * 1e-9 # from nm to user units profile_1D_y_y = profile_1D_y_y / profile_1D_y_y.std( ) * rms_y else: rms_y = self.rms_y * 1e-6 # from urad to rad yslopes = numpy.gradient( profile_1D_y_y, profile_1D_y_x[1] - profile_1D_y_x[0]) profile_1D_y_y = profile_1D_y_y / yslopes.std() * rms_y self.xx = profile_1D_y_x self.yy = profile_1D_y_y x_to_plot = self.xx y_to_plot = self.yy * 1e9 / self.si_to_user_units ny = len(self.yy) slope = numpy.zeros(ny) for i in range(ny - 1): step = self.xx[i + 1] - self.xx[i] slope[i] = numpy.arctan((self.yy[i + 1] - self.yy[i]) / step) slope[ny - 1] = slope[ny - 2] title = ' Slope error rms : %f $\mu$rad' % (slope.std() * 1e6) + '\n' + \ ' Figure error rms : %f nm' % (round(self.yy.std()* 1e9 / self.si_to_user_units, 6)) self.plot_dabam_graph(5, "heights_profile_generated", x_to_plot, y_to_plot, "Y [" + self.workspace_units_label + "]", "Z [nm]", title=title) if not not_interactive_mode: QMessageBox.information( self, "QMessageBox.information()", "Height Profile calculated: if the result is satisfactory,\nclick \'Generate Height Profile File\' to complete the operation ", QMessageBox.Ok) except Exception as exception: QMessageBox.critical(self, "Error", exception.args[0], QMessageBox.Ok) #raise exception def generate_heigth_profile_file_ni(self): self.generate_heigth_profile_file(not_interactive_mode=True) def generate_heigth_profile_file(self, not_interactive_mode=False): if not self.yy is None and not self.xx is None: try: congruence.checkDir(self.heigth_profile_file_name) sys.stdout = EmittingStream(textWritten=self.writeStdOut) numpy.savetxt(self.heigth_profile_file_name, self.yy) QMessageBox.information( self, "QMessageBox.information()", "Height Profile file " + self.heigth_profile_file_name + " written on disk", QMessageBox.Ok) self.send( "PreInput", WiserPreInputData( figure_error_file=self.heigth_profile_file_name, figure_error_step=numpy.abs(self.xx[1] - self.xx[0]), figure_user_units_to_m=self.workspace_units_to_m)) except Exception as exception: QMessageBox.critical(self, "Error", exception.args[0], QMessageBox.Ok) def call_reset_settings(self): if ConfirmDialog.confirmed(parent=self, message="Confirm Reset of the Fields?"): try: self.resetSettings() except: pass def check_fields(self): if self.modify_y == 1 or self.modify_y == 2: self.new_length = congruence.checkStrictlyPositiveNumber( self.new_length, "New Length") if self.renormalize_y == 1: self.rms_y = congruence.checkPositiveNumber(self.rms_y, "Rms Y") congruence.checkDir(self.heigth_profile_file_name) def writeStdOut(self, text): cursor = self.shadow_output.textCursor() cursor.movePosition(QTextCursor.End) cursor.insertText(text) self.shadow_output.setTextCursor(cursor) self.shadow_output.ensureCursorVisible() def selectFile(self): self.le_heigth_profile_file_name.setText( oasysgui.selectFileFromDialog( self, self.heigth_profile_file_name, "Select Output File", file_extension_filter="Data Files (*.dat)"))
class electrical_mesh_editor(QGroupBox): changed = pyqtSignal() def on_add_mesh_clicked(self): self.tab.blockSignals(True) index = self.tab.selectionModel().selectedRows() print(index) if len(index)>0: pos=index[0].row()+1 else: pos = self.tab.rowCount() self.tab.insertRow(pos) self.tab.setItem(pos,0,QTableWidgetItem("100e-9")) self.tab.setItem(pos,1,QTableWidgetItem("20")) self.save() self.tab.blockSignals(False) self.changed.emit() def on_remove_click(self, button, treeview): self.tab.blockSignals(True) index = self.tab.selectionModel().selectedRows() print(index) if len(index)>0: pos=index[0].row() self.tab.removeRow(pos) self.save() self.tab.blockSignals(False) self.changed.emit() def save(self): if self.xyz=="y": mesh_clear_ylist() elif self.xyz=="x": print("cleared") mesh_clear_xlist() elif self.xyz=="z": mesh_clear_zlist() for i in range(0,self.tab.rowCount()): mesh_add(self.xyz,float(self.tab.item(i, 0).text()),float(self.tab.item(i, 1).text())) mesh_save_all() def refresh(self): self.load() def disable_dim(self): self.tab.setItem(0,1,QTableWidgetItem("1")) self.save() def enable_dim(self): if int(self.tab.rowCount())==1: self.tab.setItem(0,1,QTableWidgetItem("10")) self.save() def load(self): self.tab.clear() self.tab.setHorizontalHeaderLabels([_("Thicknes"), _("Mesh points")]) lines=[] pos=0 if self.xyz=="y": mesh_layers=mesh_get_ylayers() layer_list=mesh_get_ylist() elif self.xyz=="x": mesh_layers=mesh_get_xlayers() layer_list=mesh_get_xlist() elif self.xyz=="z": mesh_layers=mesh_get_zlayers() layer_list=mesh_get_zlist() self.tab.setRowCount(mesh_layers) for i in range(0, mesh_layers): value = QTableWidgetItem(str(layer_list[i].thick)) self.tab.setItem(i,0,value) value = QTableWidgetItem(str(int(layer_list[i].points))) self.tab.setItem(i,1,value) def tab_changed(self, x,y): print(x,y) self.save() self.changed.emit() def __init__(self,xyz): self.xyz=xyz QGroupBox.__init__(self) self.setTitle(self.xyz) self.setStyleSheet("QGroupBox { border: 1px solid gray;}") vbox=QVBoxLayout() self.setLayout(vbox) toolbar=QToolBar() toolbar.setIconSize(QSize(48, 48)) add = QAction(QIcon(os.path.join(get_image_file_path(),"16_add.png")), _("Add "+self.xyz+" mesh layer"), self) add.triggered.connect(self.on_add_mesh_clicked) toolbar.addAction(add) remove = QAction(QIcon(os.path.join(get_image_file_path(),"16_minus.png")), _("Remove "+self.xyz+" mesh layer"), self) remove.triggered.connect(self.on_remove_click) toolbar.addAction(remove) vbox.addWidget(toolbar) self.tab = QTableWidget() self.tab.resizeColumnsToContents() self.tab.verticalHeader().setVisible(False) self.tab.clear() self.tab.setColumnCount(2) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.load() self.tab.cellChanged.connect(self.tab_changed) vbox.addWidget(self.tab)
class DictGui(Param): """A GUI for Dictionary-Parameters""" def __init__(self, project, param_name, param_alias=None, hint=None, default=None): super().__init__(project, param_name, param_alias, default) self.param_name = param_name self.param_value = dict() self.param_widget = QTableWidget(0, 2) self.param_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) if hint: self.param_widget.setToolTip(hint) self.param_widget.itemChanged.connect(self.get_param) self.param_widget.setHorizontalHeaderLabels(['key', 'value']) self.read_param() self.set_param() self.save_param() self.init_bt_layout() def set_items(self, row, key, value): key_item = QTableWidgetItem(key) key_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled) value_item = QTableWidgetItem(value) value_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled) self.param_widget.setItem(row, 0, key_item) self.param_widget.setItem(row, 1, value_item) self.param_widget.resizeColumnsToContents() def set_param(self): self.param_widget.clear() if len(self.param_value) > 0: self.param_widget.setRowCount(len(self.param_value)) for row, (key, value) in enumerate(self.param_value.items()): self.set_items(row, str(key), str(value)) def get_param(self): param_dict = dict() for row in range(self.param_widget.rowCount()): row_item = self.param_widget.item(row, 0) value_item = self.param_widget.item(row, 1) if row_item and value_item: try: key = literal_eval(row_item.text()) except (ValueError, SyntaxError): key = row_item.text() try: value = literal_eval(value_item.text()) except (ValueError, SyntaxError): value = value_item.text() param_dict.update({key: value}) self.param_widget.resizeColumnsToContents() self.param_value = param_dict self.save_param() return self.param_value def add_item(self): row = self.param_widget.rowCount() self.param_widget.insertRow(row) self.set_items(row, '_None_key_', '_None_value_') self.param_widget.resizeColumnsToContents() self.get_param() def remove_item(self): row = self.param_widget.currentRow() if row is not None: self.param_widget.removeRow(row) self.get_param()
class Ui_MainWindow(object): #tworzenie zmienncyh tymczasowych current_unit = 0 names_list = [] Readed_registers = [] Responded_messages_list = [] #zakoncz dzialanie programu po zamknieciu okna def quit(self): sys.exit(app.exec()) #tworzenie obiektow okna admina def setupUi(self, MainWindow): serwervxi.Listen_connection.listen() MainWindow.setObjectName("Kinco_Driver") MainWindow.resize(800, 600) MainWindow.setFixedSize(MainWindow.size()) self.centralwidget = QtWidgets.QWidget(MainWindow) self.centralwidget.setObjectName("centralwidget") self.pushButton = QtWidgets.QPushButton(self.centralwidget) self.pushButton.setGeometry(QtCore.QRect(50, 475, 100, 60)) self.pushButton.setObjectName("pushButton") self.pushButton_2 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_2.setGeometry(QtCore.QRect(180, 475, 100, 60)) self.pushButton_2.setObjectName("pushButton_2") self.pushButton_3 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_3.setGeometry(QtCore.QRect(310, 475, 100, 60)) self.pushButton_3.setObjectName("pushButton_3") self.pushButton_4 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_4.setGeometry(QtCore.QRect(440, 475, 100, 60)) self.pushButton_4.setObjectName("pushButton_4") self.pushButton_5 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_5.setGeometry(QtCore.QRect(500, 55, 50, 25)) self.pushButton_5.setObjectName("pushButton_5") self.pushButton_6 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_6.setGeometry(QtCore.QRect(725, 300, 50, 25)) self.pushButton_6.setObjectName("pushButton_5") self.pushButton_7 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_7.setGeometry(QtCore.QRect(570, 475, 100, 60)) self.pushButton_7.setObjectName("pushButton_7") self.pushButton_8 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_8.setGeometry(QtCore.QRect(650, 300, 50, 25)) self.pushButton_8.setObjectName("pushButton_7") self.pushButton_9 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_9.setGeometry(QtCore.QRect(500, 5, 120, 25)) self.pushButton_9.setObjectName("pushButton_7") self.pushButton_10 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_10.setGeometry(QtCore.QRect(630, 440, 130, 25)) self.pushButton_10.setObjectName("pushButton_7") self.pushButton_11 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_11.setGeometry(QtCore.QRect(630, 40, 130, 25)) self.pushButton_11.setObjectName("pushButton_7") self.pushButton_12 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_12.setGeometry(QtCore.QRect(630, 70, 130, 25)) self.pushButton_12.setObjectName("pushButton_7") self.pushButton_13 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_13.setGeometry(QtCore.QRect(630, 100, 130, 25)) self.pushButton_13.setObjectName("pushButton_7") self.pushButton_14 = QtWidgets.QPushButton(self.centralwidget) self.pushButton_14.setGeometry(QtCore.QRect(630, 5, 130, 25)) self.pushButton_14.setObjectName("pushButton_7") self.scrollArea = QtWidgets.QScrollArea(self.centralwidget) self.scrollArea.setGeometry(QtCore.QRect(50, 140, 701, 100)) self.scrollArea.setWidgetResizable(True) self.scrollArea.setObjectName("scrollArea") self.scrollAreaWidgetContents = QtWidgets.QWidget() self.scrollAreaWidgetContents.setGeometry(QtCore.QRect( 0, 100, 699, 99)) self.scrollAreaWidgetContents.setObjectName("scrollAreaWidgetContents") self.scrollArea.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) self.scrollArea.setWidgetResizable(True) self.scrollArea.setWidget(self.scrollAreaWidgetContents) self.scrollArea2 = QtWidgets.QScrollArea(self.centralwidget) self.scrollArea2.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) self.scrollArea2.setGeometry(QtCore.QRect(50, 330, 701, 100)) self.scrollArea2.setWidgetResizable(True) self.scrollArea2.setObjectName("scrollArea") self.scrollArea2WidgetContents = QtWidgets.QWidget() self.scrollArea2WidgetContents.setGeometry(QtCore.QRect(0, 0, 699, 99)) self.scrollArea2WidgetContents.setObjectName( "scrollAreaWidgetContents") self.scrollArea2.setWidget(self.scrollArea2WidgetContents) self.scrollArea2.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) self.scrollArea2.setWidgetResizable(True) self.scrollArea2.setWidget(self.scrollAreaWidgetContents) self.label = QtWidgets.QLabel(self.centralwidget) self.label.setGeometry(QtCore.QRect(50, 5, 331, 25)) self.label.setObjectName("label") self.label_2 = QtWidgets.QLabel(self.centralwidget) self.label_2.setGeometry(QtCore.QRect(125, 5, 361, 25)) self.label_2.setObjectName("label_2") self.label_3 = QtWidgets.QLabel(self.centralwidget) self.label_3.setGeometry(QtCore.QRect(570, 530, 211, 25)) self.label_3.setObjectName("label_3") self.label_4 = QtWidgets.QLabel(self.centralwidget) self.label_4.setGeometry(QtCore.QRect(30, 265, 100, 25)) self.label_4.setObjectName("label_3") self.label_5 = QtWidgets.QLabel(self.centralwidget) self.label_5.setGeometry(QtCore.QRect(30, 295, 100, 25)) self.label_5.setObjectName("label_3") self.label_6 = QtWidgets.QLabel(self.centralwidget) self.label_6.setGeometry(QtCore.QRect(375, 5, 70, 25)) self.label_6.setObjectName("label_3") self.label_7 = QtWidgets.QLabel(self.centralwidget) self.label_7.setGeometry(QtCore.QRect(250, 5, 100, 25)) self.label_7.setObjectName("label_3") self.label_8 = QtWidgets.QLabel(self.centralwidget) self.label_8.setFont(QFont('Arial', 12)) self.label_8.setGeometry(QtCore.QRect(40, 70, 500, 60)) self.label_8.setObjectName("label_3") self.label_9 = QtWidgets.QLabel(self.scrollArea) self.label_9.setGeometry(QtCore.QRect(0, 0, 500, 25)) self.label_9.setObjectName("label_3") self.label_11 = QtWidgets.QLabel(self.centralwidget) self.label_11.setGeometry(QtCore.QRect(120, 245, 110, 25)) self.label_12 = QtWidgets.QLabel(self.centralwidget) self.label_12.setGeometry(QtCore.QRect(230, 245, 140, 25)) self.label_13 = QtWidgets.QLabel(self.centralwidget) self.label_13.setGeometry(QtCore.QRect(380, 245, 140, 25)) self.label_14 = QtWidgets.QLabel(self.centralwidget) self.label_14.setGeometry(QtCore.QRect(530, 245, 130, 25)) self.label_15 = QtWidgets.QLabel(self.centralwidget) self.label_15.setGeometry(QtCore.QRect(680, 245, 80, 25)) self.label_16 = QtWidgets.QLabel(self.centralwidget) self.label_16.setGeometry(QtCore.QRect(10, 245, 80, 25)) self.label_17 = QtWidgets.QLabel(self.centralwidget) self.label_17.setGeometry(QtCore.QRect(50, 530, 300, 60)) self.deafult_checkbox = QtWidgets.QCheckBox(self.centralwidget) self.deafult_checkbox.move(70, 250) self.coordination_box_y = QtWidgets.QTextEdit(self.centralwidget) self.coordination_box_y.setGeometry(QtCore.QRect(120, 295, 80, 25)) self.coordination_box_x = QtWidgets.QTextEdit(self.centralwidget) self.coordination_box_x.setGeometry(QtCore.QRect(120, 265, 80, 25)) self.acceleration_box_x = QtWidgets.QTextEdit(self.centralwidget) self.acceleration_box_x.setGeometry(QtCore.QRect(260, 265, 80, 25)) self.decceleration_box_x = QtWidgets.QTextEdit(self.centralwidget) self.decceleration_box_x.setGeometry(QtCore.QRect(400, 265, 80, 25)) self.velocity_box_x = QtWidgets.QTextEdit(self.centralwidget) self.velocity_box_x.setGeometry(QtCore.QRect(540, 265, 80, 25)) self.acceleration_box_y = QtWidgets.QTextEdit(self.centralwidget) self.acceleration_box_y.setGeometry(QtCore.QRect(260, 295, 80, 25)) self.decceleration_box_y = QtWidgets.QTextEdit(self.centralwidget) self.decceleration_box_y.setGeometry(QtCore.QRect(400, 295, 80, 25)) self.velocity_box_y = QtWidgets.QTextEdit(self.centralwidget) self.velocity_box_y.setGeometry(QtCore.QRect(540, 295, 80, 25)) self.Message_edit = QtWidgets.QTextEdit(self.centralwidget) self.Message_edit.setGeometry(QtCore.QRect(375, 55, 100, 25)) self.Message_edit2 = QtWidgets.QTextEdit(self.centralwidget) self.Message_edit2.setGeometry(QtCore.QRect(125, 55, 100, 25)) self.Message_edit3 = QtWidgets.QTextEdit(self.centralwidget) self.Message_edit3.setGeometry(QtCore.QRect(250, 55, 100, 25)) self.unit_choice = QtWidgets.QComboBox(self.centralwidget) self.unit_choice.setGeometry(QtCore.QRect(50, 25, 50, 25)) self.positioning_choice = QtWidgets.QComboBox(self.centralwidget) self.positioning_choice.setGeometry(QtCore.QRect(650, 265, 100, 25)) self.function_choice = QtWidgets.QComboBox(self.centralwidget) self.function_choice.setGeometry(QtCore.QRect(125, 25, 100, 25)) self.register_choice = QtWidgets.QComboBox(self.centralwidget) self.register_choice.setGeometry(QtCore.QRect(250, 25, 100, 25)) self.message_choice = QtWidgets.QComboBox(self.centralwidget) self.message_choice.setGeometry(QtCore.QRect(375, 25, 100, 25)) self.responded_messages = QWidget() self.vbox = QVBoxLayout() self.responded_messages2 = QWidget() self.vbox2 = QVBoxLayout() self.table = QTableWidget(self.centralwidget) self.table.setGeometry(QtCore.QRect(20, 330, 760, 100)) self.table.setColumnCount(3) self.table.setRowCount(1000) self.table.setColumnWidth(0, 235) self.table.setColumnWidth(1, 235) self.table.setColumnWidth(2, 235) self.table.setHorizontalHeaderLabels( ['Position X', 'Position Y', 'name']) self.table.resizeRowsToContents() self.table.setMinimumWidth(720) self.table.setMinimumHeight(100) #podzielenie okna na czesc z menu i czesc z obiektami MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21)) self.menubar.setObjectName("menubar") MainWindow.setMenuBar(self.menubar) self.statusbar = QtWidgets.QStatusBar(MainWindow) self.statusbar.setObjectName("statusbar") MainWindow.setStatusBar(self.statusbar) #dodanie zegara na dole okna self.DigitalClock = DigitalClock(self.centralwidget) self.DigitalClock.setGeometry(QtCore.QRect(570, 553, 130, 21)) self.retranslateUi(MainWindow) QtCore.QMetaObject.connectSlotsByName(MainWindow) def send_message(self): #wczytaj wartosci nazwy rejestru, funkcji, jednostki, oraz #wysylanej wiadomosci podanych przez uzytkownika. function_choosed = self.function_choice.currentText() Admin_backend.message_sending.Register = self.register_choice.currentText( ) Admin_backend.message_sending.Unit = self.unit_choice.currentText() Admin_backend.message_sending.message = self.Message_edit.toPlainText() #jesli wybrane jest czytanie z rejestru if (function_choosed == 'read'): #wywolaj funkcje czytajaca z rejestr result = Admin_backend.message_sending.read_register() #zapisz do tabeli odebrana wiadomosc if (result == 0): self.Responded_messages_list.append( Admin_backend.Register_respond[ len(Admin_backend.Register_respond) - 1]) object = QLabel(self.Responded_messages_list[ len(self.Responded_messages_list) - 1]) self.vbox.addWidget(object) self.responded_messages.setLayout(self.vbox) self.scrollArea.setWidget(self.responded_messages) #wyczysc zmienna z wczytaneym rejestrem else: self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("check connection") self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) self.msgbox.show() Admin_backend.Register_respond = [] elif (function_choosed == 'write'): #jesli wybrana funkcja jest pisanie do rejestru wywolaj #metode piszaca do rejestru result = Admin_backend.message_sending.write_register() #korzystajac z flagi podniesionej przez wywolana funkcje #wyswietl informacji o bledzie podczas wysylania wiadomosci if (result != 0): self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) if (result == 1): self.msgbox.setText("wrong type of message") elif (result == 2): self.msgbox.setText("value of message out of limit") elif (result == 3): self.msgbox.setText("value of message out of limit") else: self.msgbox.setText("Check connection") self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) self.msgbox.show() #wyswietl wczytane informacje z nowo zapisanego rejsetru self.Responded_messages_list.append(Admin_backend.Register_respond[ len(Admin_backend.Register_respond) - 1]) object = QLabel( self.Responded_messages_list[len(self.Responded_messages_list) - 1]) self.vbox.addWidget(object) self.responded_messages.setLayout(self.vbox) self.scrollArea.setWidget(self.responded_messages) #wyzeroj zmienne kontrolne Admin_backend.Register_respond = [] #funkcja pobiera aktualna date def getDate(self): date = QDate.currentDate() return date.toString(Qt.DefaultLocaleLongDate) #callback wybrania wartosci okienka unit zapisuje wybrana zmienna do #odpowiedniego zmiennej w klasie admin_backend def unit_selected(self, value): if (int(value) == 1): Admin_backend.unit_choice = 0 else: Admin_backend.unit_choice = 1 print("to dziala") #callback wybrania wartosci okienka function zapisuje wybrana zmienna #do odpowiedniego zmiennej w klasie admin_backend i wczytuje mozliwe #wartosci okienka nazw rejestrow def Function_selected(self, value): self.register_choice.clear() Admin_backend.function_value = value names_list = Admin_backend.comboboxes.registers_names() self.register_choice.addItems(names_list) Admin_backend.registers_names_list = [] self.Message_edit2.setText(value) #callback wybrania wartosci okienka nazwy rejsestru zapisuje wybrana #zmienna do odpowiedniego zmiennej w klasie admin_backend i wczytuje #mozliwe wartosci okienka mozliwych wiadomosci def name_selected(self, value): self.message_choice.clear() Admin_backend.register_name_value = value messages_list = Admin_backend.comboboxes.messages_names() self.message_choice.addItems(messages_list) Admin_backend.message_names_list = [] if (Admin_backend.label_text != []): self.label_8.setText(Admin_backend.label_text[0]) Admin_backend.label_text = [] self.Message_edit3.setText(value) #callback wybrania wartosci okienka wiadomosci zapisuje wybrana #zmienna do odpowiedniego zmiennej w klasie admin_backend i wyswietla #podpwiedz do danej wiadomosci def message_selected(self, value): Admin_backend.message_name_value = value print(Admin_backend.label_text) Admin_backend.comboboxes.message_description() if (Admin_backend.label_text != []): self.label_8.setText(Admin_backend.label_text[0]) Admin_backend.label_text = [] value = self.message_choice.currentText() print(value) if value != 'inc' and value != 'RPM' and value != 'AMP' and value != 'number' and value != 'rp/s^2': self.Message_edit.setText(value) #callback przcisku home do zaimplementopwania def Home_window(self): self.window = QMainWindow() self.Home_ui = Home_window.Ui_Home_Window() self.Home_ui.setupUi(self.window) self.window.show() #callback przycisku register uruchamia okno rejsetru def Register_window(self): #odpytaj serwomechnizm o stan jego rejestrow connection_result = Admin_backend.message_sending.check_connection() if (connection_result == 0): self.window = QMainWindow() self.Register_ui = Register_window.Ui_Register_Window() self.Register_ui.setupUi(self.window) self.window.show() else: self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("Check connection") self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) self.msgbox.show() #callback przycisku test wykonuje test serwomechnizmow a w razie #problemow wyswietla informacje o bledzie def Test_clicked(self): #wywolaj metode wykoujaca test Admin_backend.stop_thread = 0 self.check_window() self.testTask() def check_window(self): global check_window check_window = Check_move_Window.Ui_Check_move_Window() print(check_window) self.ui = check_window check_window.setupUi(self.ui) check_window.show() def moveTask(self): # Step 2: Create a QThread object self.thread = QThread() # Step 3: Create a worker object self.moving = Admin_backend.moving() # Step 4: Move worker to the thread self.moving.moveToThread(self.thread) # Step 5: Connect signals and slots self.thread.started.connect(self.moving.do_move) self.moving.finished.connect(self.thread.quit) self.moving.finished.connect(self.moving.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.moving.progress2.connect(self.update_move_window) self.moving.progress.connect(self.show_messagebox) self.moving.progress3.connect(self.update_unit) self.moving.stop_current_thread.connect(self.thread.quit) # Step 6: Start the thread self.thread.start() self.pushButton_5.setEnabled(False) self.thread.finished.connect( lambda: self.pushButton_5.setEnabled(True)) self.pushButton_6.setEnabled(False) self.thread.finished.connect( lambda: self.pushButton_6.setEnabled(True)) self.pushButton_8.setEnabled(False) self.thread.finished.connect( lambda: self.pushButton_8.setEnabled(True)) #funkcja odpowiedzialna za porusznie sie serwomechanizmow def update_unit(self, unit): self.current_unit = unit def testTask(self): # Step 2: Create a QThread object self.thread = QThread() # Step 3: Create a worker object self.moving = Admin_backend.moving() # Step 4: Move worker to the thread self.moving.moveToThread(self.thread) # Step 5: Connect signals and slots self.thread.started.connect(self.moving.do_test) self.moving.finished.connect(self.thread.quit) self.moving.finished.connect(self.moving.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.moving.progress2.connect(self.update_move_window) self.moving.progress3.connect(self.update_unit) self.moving.progress.connect(self.show_messagebox2) self.moving.stop_current_thread.connect(self.thread.quit) # Step 6: Start the thread self.thread.start() self.pushButton_5.setEnabled(False) self.thread.finished.connect( lambda: self.pushButton_5.setEnabled(True)) self.pushButton_6.setEnabled(False) self.thread.finished.connect( lambda: self.pushButton_6.setEnabled(True)) self.pushButton_8.setEnabled(False) self.thread.finished.connect( lambda: self.pushButton_8.setEnabled(True)) #funkcja odpowiedzialna za porusznie sie serwomechanizmow def apimoveTask(self): # Step 2: Create a QThread object self.thread = QThread() # Step 3: Create a worker object self.moving = Admin_backend.moving() # Step 4: Move worker to the thread self.moving.moveToThread(self.thread) # Step 5: Connect signals and slots self.thread.started.connect(self.moving.do_test) self.moving.finished.connect(self.thread.quit) self.moving.finished.connect(self.moving.deleteLater) self.thread.finished.connect(self.thread.deleteLater) # Step 6: Start the thread self.thread.start() def update_move_window(self, point): global check_window curr_text = "" if self.current_unit == 1: curr_text = "x" else: curr_text = "y" uplabel = ("current position of axis " + curr_text + " : " + str(point)) Check_move_Window.Ui_Check_move_Window.update_label( check_window, uplabel) def show_messagebox(self, result): self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) global check_window check_window.close() if (result == 1): self.msgbox.setText("wrong type of message") elif (result == 2): self.msgbox.setText("one of value out of limit") elif (result == 3): self.msgbox.setText("one of value out of limit") elif (result == 4): self.msgbox.setText("Check connection") elif (result == 5): self.msgbox.setText("Move Error") elif (result == 6): self.msgbox.setText("Invalid input data") else: self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Information) self.msgbox.setText("Move completed succesful") self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) self.msgbox.show() def show_messagebox2(self, result): if (result != 0): self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("Test Error") self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) self.msgbox.show() else: self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Information) self.msgbox.setText("Test completed succesful") self.msgbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) self.msgbox.show() def api_move(self, x, y, x_vel, y_vel, X_acc, y_acc, x_dec, y_dec, positioning, deafult): result = 0 try: #pobierz wartosci o ruchu podane przez uzytkownika i zapisz #w odpowienich zmiennych klasy asmin_backend Admin_backend.moving.position_x = x Admin_backend.moving.position_y = y Admin_backend.moving.zero = positioning except Exception: traceback.print_exc() result = 6 self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("Invalid input data") self.msgbox.show() #jesli aktualnie program nie namesession_ui wykonuje ruchu if (deafult == 0): try: #zapisz wczytane uzytkownika informacje o ruchu #do odpowiednich zmienncyh klasy admin_backend Admin_backend.moving.acceleration_x = round( 163.84 * int(self.acceleration_box_x.toPlainText())) Admin_backend.moving.decceleration_x = round( 163.84 * int(self.decceleration_box_x.toPlainText())) Admin_backend.moving.velocity_x = round( 2730 * int(self.velocity_box_x.toPlainText())) Admin_backend.moving.acceleration_y = round( 163.84 * int(self.acceleration_box_y.toPlainText())) Admin_backend.moving.decceleration_y = round( 163.84 * int(self.decceleration_box_y.toPlainText())) Admin_backend.moving.velocity_y = round( 2730 * int(self.velocity_box_x.toPlainText())) Admin_backend.moving.zero = self.positioning_choice.currentText( ) except Exception: traceback.print_exc() result = 6 self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("Invalid input data") self.msgbox.show() else: Admin_backend.move_deafult_flag[0] = 1 #wyswietl informacje o statusie ruchu if (result != 6): Admin_backend.stop_thread = 0 self.check_window() self.apimoveTask() def Move_clicked(self): result = 0 try: #pobierz wartosci o ruchu podane przez uzytkownika i zapisz #w odpowienich zmiennych klasy asmin_backend Admin_backend.moving.position_x = int( self.coordination_box_x.toPlainText()) Admin_backend.moving.position_y = int( self.coordination_box_y.toPlainText()) Admin_backend.moving.zero = self.positioning_choice.currentText() except Exception: traceback.print_exc() result = 6 self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("resultInvalid input data") self.msgbox.show() #jesli aktualnie program nie namesession_ui wykonuje ruchu if (Admin_backend.move_deafult_flag[0] == 0): try: #zapisz wczytane uzytkownika informacje o ruchu #do odpowiednich zmienncyh klasy admin_backend Admin_backend.moving.acceleration_x = round( 163.84 * int(self.acceleration_box_x.toPlainText())) Admin_backend.moving.decceleration_x = round( 163.84 * int(self.decceleration_box_x.toPlainText())) Admin_backend.moving.velocity_x = round( 2730 * int(self.velocity_box_x.toPlainText())) Admin_backend.moving.acceleration_y = round( 163.84 * int(self.acceleration_box_y.toPlainText())) Admin_backend.moving.decceleration_y = round( 163.84 * int(self.decceleration_box_y.toPlainText())) Admin_backend.moving.velocity_y = round( 2730 * int(self.velocity_box_x.toPlainText())) Admin_backend.moving.zero = self.positioning_choice.currentText( ) except Exception: traceback.print_exc() result = 6 self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("Invalid input data") self.msgbox.show() #wyswietl informacje o statusie ruchu if (result != 6): Admin_backend.stop_thread = 0 self.check_window() self.moveTask() #Callback checkboxu wylacza mozliwosc dodawania swoich wartosci do #ruchu oprocz wspolrzednych def deafult_checkbox_clicked(self, state): Admin_backend.move_deafult_flag = [] if str(state) == "True": self.acceleration_box_x.setDisabled(True) self.decceleration_box_x.setDisabled(True) self.velocity_box_x.setDisabled(True) self.acceleration_box_y.setDisabled(True) self.decceleration_box_y.setDisabled(True) self.velocity_box_y.setDisabled(True) Admin_backend.move_deafult_flag.append(1) else: self.acceleration_box_x.setDisabled(False) self.decceleration_box_x.setDisabled(False) self.velocity_box_x.setDisabled(False) self.acceleration_box_y.setDisabled(False) self.decceleration_box_y.setDisabled(False) self.velocity_box_y.setDisabled(False) Admin_backend.move_deafult_flag.append(0) def savepoint_callback(self): global table_end global Table Admin_backend.button_callbacks.savepoint_button_callback() item1 = QTableWidgetItem(str(Admin_backend.Position_save_info[0])) item2 = QTableWidgetItem(str(Admin_backend.Position_save_info[1])) item3 = QTableWidgetItem("Default name " + str(table_end)) self.table.setItem(table_end, 0, item1) self.table.setItem(table_end, 1, item2) self.table.setItem(table_end, 2, item3) self.table.selectRow(table_end) table_end = table_end + 1 def previous_callback(self): saved_coor = Admin_backend.button_callbacks.previous_buttton_callback() self.coordination_box_x.setText(str(saved_coor[0])) self.coordination_box_y.setText(str(saved_coor[1])) if (Admin_backend.current_point > -1): self.table.selectRow(Admin_backend.current_point) def next_callback(self): saved_coor = Admin_backend.button_callbacks.next_buttton_callback() self.coordination_box_x.setText(str(saved_coor[0])) self.coordination_box_y.setText(str(saved_coor[1])) if (Admin_backend.current_point < 1000): self.table.selectRow(Admin_backend.current_point) def savesession_callback(self): global Table global table_end Table = [[0 for x in range(self.table.columnCount())] for y in range(table_end)] for i in range(self.table.columnCount()): for k in range(table_end): print([k, i]) print(self.table.item(k, i).text()) Table[k][i] = self.table.item(k, i).text() Admin_backend.Points = Table self.namesession_ui = Namesession.Ui_NameSession_Window() self.namesession_ui.setupUi(self.namesession_ui) self.namesession_ui.show() def readsession_callback(self): self.thread = QThread() self.readsession_ui = Session_records.Ui_Session_records_Window() self.readsession_ui.moveToThread(self.thread) self.readsession_ui.setupUi(self.readsession_ui) self.thread.started.connect(self.readsession_ui.show) self.readsession_ui.finished.connect(self.update_table) self.readsession_ui.finished.connect(self.thread.quit) self.readsession_ui.finished.connect(self.readsession_ui.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.thread.start() def update_table(self): try: global table_end Points = Admin_backend.New_points counter = 0 print(Points) self.table.clear() Admin_backend.Saved_points = [] for point in Points: Admin_backend.Saved_points.append( [str(point[1]), str(point[2])]) Admin_backend.current_point = (len( Admin_backend.Saved_points)) - 1 item1 = QTableWidgetItem(str(point[1])) item2 = QTableWidgetItem(str(point[2])) item3 = QTableWidgetItem(str(point[3])) self.table.setItem(counter, 0, item1) self.table.setItem(counter, 1, item2) self.table.setItem(counter, 2, item3) counter = counter + 1 table_end = counter Admin_backend.current_point = 0 except Exception: traceback.print_exc() def error_reset_callback(self): result = Admin_backend.button_callbacks.error_reset() if (result != 0): self.msgbox = QMessageBox() self.msgbox.setIcon(QMessageBox.Critical) self.msgbox.setText("Reset error") def session_movement_callback(self): self.currentPosition_ui = Current_position.Ui_current_position_window() self.currentPosition_ui.setupUi(self.currentPosition_ui) self.currentPosition_ui.show() def motors_off_callback(self): Admin_backend.button_callbacks.motors_off() def Zero_current_callback(self): Admin_backend.button_callbacks.Zero_current() #funkcja uruchamiana przy starcie okna przypsiujaca wartosci oknu #gui oraz deklarujaca callbacki def retranslateUi(self, MainWindow): try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("8.8.8.8", 80)) ip_adress = s.getsockname()[0] except Exception: ip_adress = "Check connection to switch" _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "Kinco Driver")) self.pushButton.setText(_translate("MainWindow", "Home")) self.pushButton.clicked.connect(self.Home_window) self.pushButton_2.setText(_translate("MainWindow", "Save point")) self.pushButton_2.clicked.connect(self.savepoint_callback) self.pushButton_3.setText(_translate("MainWindow", "Previous")) self.pushButton_3.clicked.connect(self.previous_callback) self.pushButton_4.setText(_translate("MainWindow", "Next")) self.pushButton_4.clicked.connect(self.next_callback) self.pushButton_5.setText(_translate("MainWindow", "Send")) self.pushButton_5.clicked.connect(self.send_message) self.pushButton_6.setText(_translate("MainWindow", "test")) self.pushButton_6.clicked.connect(self.Test_clicked) self.pushButton_7.setText(_translate("MainWindow", "Save session")) self.pushButton_7.clicked.connect(self.savesession_callback) self.pushButton_8.setText(_translate("MainWindow", "Move")) self.pushButton_8.clicked.connect(self.Move_clicked) self.pushButton_9.setText(_translate("MainWindow", "Registers_status")) self.pushButton_9.clicked.connect(self.Register_window) self.pushButton_10.setText(_translate("MainWindow", "Read Session")) self.pushButton_10.clicked.connect(self.readsession_callback) self.pushButton_11.setText(_translate("MainWindow", "Reset Error")) self.pushButton_11.clicked.connect(self.error_reset_callback) self.pushButton_12.setText(_translate("MainWindow", "Session Movement")) self.pushButton_12.clicked.connect(self.session_movement_callback) self.pushButton_13.setText(_translate("MainWindow", "motors off")) self.pushButton_13.clicked.connect(self.motors_off_callback) self.pushButton_14.setText( _translate("MainWindow", "Zero current point")) self.pushButton_14.clicked.connect(self.Zero_current_callback) self.positioning_choice.addItems(Admin_backend.Positioning_values) self.deafult_checkbox.clicked.connect(self.deafult_checkbox_clicked) self.unit_choice.addItems(Constants.units) self.unit_choice.currentTextChanged.connect(self.unit_selected) self.function_choice.currentTextChanged.connect(self.Function_selected) self.function_choice.addItems(Constants.function_select) self.register_choice.currentTextChanged.connect(self.name_selected) self.message_choice.currentTextChanged.connect(self.message_selected) self.label.setText(_translate("MainWindow", "Unit:")) self.label_2.setText(_translate("MainWindow", "Function:")) self.label_3.setText(_translate("MainWindow", self.getDate())) self.label_4.setText(_translate("MainWindow", "Y Coordinate:")) self.label_5.setText(_translate("MainWindow", "X Coordinate:")) self.label_6.setText(_translate("MainWindow", "Message:")) self.label_7.setText(_translate("MainWindow", "Register Name:")) self.label_9.setText(_translate("MainWindow", " ")) self.label_11.setText(_translate("MainWindow", "Position(inc):")) self.label_12.setText(_translate("MainWindow", "Acceleration(rp/s^2):")) self.label_13.setText(_translate("MainWindow", "Deceleration(rp/s^2):")) self.label_14.setText(_translate("MainWindow", "Velocity(rpm):")) self.label_15.setText(_translate("MainWindow", "Zero:")) self.label_16.setText(_translate("MainWindow", "Deafult:")) self.label_17.setText( _translate("MainWindow", "Current IP: %s" % (ip_adress))) self.DigitalClock.setStyleSheet('background-color: black', ) self.Register_window()
class SessionViewer(QWidget): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.setMinimumSize(1100, 400) main_layout = QHBoxLayout() main_layout.setSpacing(5) self.setLayout(main_layout) list_column = QVBoxLayout() main_layout.addLayout(list_column, stretch=1) refresh_button = QPushButton('🔄 Refresh') refresh_button.setFont(cn.EMOJI_FONT) refresh_button.clicked.connect(self.refresh_list) list_column.addWidget(refresh_button) self.session_list = QListWidget() self.session_list.currentItemChanged.connect(self.show_session) list_column.addWidget(self.session_list) self.refresh_list() self.info_column = QVBoxLayout() main_layout.addLayout(self.info_column, stretch=1) self.info_column.addWidget(QLabel('Selected session info:')) self.session_info_table = QTableWidget() self.session_info_table.setColumnCount(2) self.session_info_table.horizontalHeader().setStretchLastSection(True) self.info_column.addWidget(self.session_info_table) self.info_column.addWidget(QLabel('Contained gestures:')) self.gesture_list = QListWidget() self.gesture_list.currentItemChanged.connect(self.show_gesture) self.info_column.addWidget(self.gesture_list) self.data_column = QVBoxLayout() self.data_column.setContentsMargins(0, 0, 0, 0) main_layout.addLayout(VerticalScrollableExtension( self.data_column, direction=QBoxLayout.TopToBottom, scrolled_spacing=10), stretch=3) self.current_session_data = None self.current_gesture_names = None @staticmethod def load_session_data(session_name): file = f'data/gestures/{session_name}' with open(file, 'rb') as f: data = pickle.load(f) gesture_keys = [ item for item in data if type(data[item]) == np.ndarray ] return data, sorted(gesture_keys, key=lambda x: str(x).zfill(5)) @staticmethod def load_session_list(): return sorted( filter( lambda x: x.startswith('s-') and x.count(cn.FILE_NAME_SEPARATOR ) == 2, os.listdir(cn.DATA_FOLDER))) def refresh_list(self): self.session_list.clear() self.session_list.addItems(SessionViewer.load_session_list()) def cleanup_shown_session(self): self.session_info_table.clear() self.gesture_list.clearSelection() self.gesture_list.clear() for i in range(self.data_column.count()): self.data_column.itemAt(i).widget().plot_data(None) def show_session(self, current_item): if not current_item: return self.cleanup_shown_session() session_name = current_item.text() self.current_session_data, self.current_gesture_names = SessionViewer.load_session_data( session_name) self.session_info_table.setRowCount(2 + len(self.current_session_data) - len(self.current_gesture_names)) row = 0 for info in self.current_session_data: if info in self.current_gesture_names: continue self.session_info_table.setItem(row, 0, QTableWidgetItem(info)) self.session_info_table.setItem( row, 1, QTableWidgetItem(str(self.current_session_data[info]))) row += 1 self.session_info_table.setItem(row, 0, QTableWidgetItem('Gestures')) self.session_info_table.setItem( row, 1, QTableWidgetItem(str(len(self.current_gesture_names)))) self.session_info_table.setItem(row + 1, 0, QTableWidgetItem('Instances')) self.session_info_table.setItem( row + 1, 1, QTableWidgetItem( str( sum( map(lambda name: len(self.current_session_data[name]), self.current_gesture_names))))) self.gesture_list.addItems( map( lambda name: f'{name} ({len(self.current_session_data[name])} inst.)', self.current_gesture_names)) def show_gesture(self): current_gesture_data = self.current_session_data[ self.current_gesture_names[self.gesture_list.currentIndex().row()]] new_count = len(current_gesture_data) old_count = self.data_column.count() for i in range(old_count, new_count): self.data_column.addWidget(StaticSignalWidget()) for i in range(new_count, old_count): self.data_column.itemAt(i).widget().plot_data(None) for i, instance in enumerate(current_gesture_data): # We use a function here, to create a temporary scope for index & data w = self.data_column.itemAt(i).widget() w.plot_data(instance)
class layer_widget(QWidget): changed = pyqtSignal() def combo_changed(self): self.save_model() self.emit_change() def tab_changed(self, x,y): self.save_model() self.emit_change() def emit_change(self): if self.optics_window!=False: if self.optics_window.isVisible()==True: self.optics_window.update() self.changed.emit() def sync_to_electrical_mesh(self): tot=0 for i in range(0,len(self.model)): if yes_no(self.model[i][COLUMN_DEVICE])==True: tot=tot+float(self.model[i][COLUMN_THICKNES]) lines=[] if inp_load_file(lines,os.path.join(os.getcwd(),"mesh_y.inp"))==True: mesh_layers=int(inp_search_token_value(lines, "#mesh_layers")) if mesh_layers==1: inp_update_token_value(os.path.join(os.getcwd(),"mesh_y.inp"), "#mesh_layer_length0", str(tot),1) def layer_type_edit(self): for i in range(0,self.tab.rowCount()): if tab_get_value(self.tab,i,3).lower()=="active layer" and tab_get_value(self.tab,i,4).startswith("dos")==False: tab_set_value(self.tab,i,4,epitay_get_next_dos()) tab_set_value(self.tab,i,5,epitay_get_next_pl()) mat_dir=os.path.join(get_materials_path(),tab_get_value(self.tab,i,2)) new_file=tab_get_value(self.tab,i,4)+".inp" if inp_isfile(new_file)==False: inp_copy_file(new_file,os.path.join(mat_dir,"dos.inp")) new_file=tab_get_value(self.tab,i,5)+".inp" if inp_isfile(new_file)==False: inp_copy_file(new_file,os.path.join(mat_dir,"pl.inp")) if tab_get_value(self.tab,i,3).lower()!="active layer" and tab_get_value(self.tab,i,4).startswith("dos")==True: tab_set_value(self.tab,i,4,tab_get_value(self.tab,i,3)) tab_set_value(self.tab,i,5,"none") self.save_model() self.emit_change() def rebuild_mat_list(self): self.material_files=[] mat=find_materials() for i in range(0,len(mat)): self.material_files.append(mat[i]) scan_remove_file(os.path.join(get_materials_path(),mat[i])) scan_item_add(os.path.join("materials",mat[i],"fit.inp"),"#wavelength_shift_alpha","Absorption spectrum wavelength shift",1) scan_item_add(os.path.join("materials",mat[i],"fit.inp"),"#n_mul","Refractive index spectrum multiplier",1) scan_item_add(os.path.join("materials",mat[i],"fit.inp"),"#alpha_mul","Absorption spectrum multiplier",1) def callback_view_materials(self): dialog=gpvdm_open(get_materials_path()) dialog.show_inp_files=False ret=dialog.window.exec_() if ret==QDialog.Accepted: if os.path.isfile(os.path.join(dialog.get_filename(),"mat.inp"))==True: self.mat_window=materials_main(dialog.get_filename()) self.mat_window.show() else: plot_gen([dialog.get_filename()],[],"auto") def on_move_down(self): tab_move_down(self.tab) self.save_model() self.emit_change() def callback_optics_sim(self, widget, data=None): help_window().help_set_help(["optics.png",_("<big><b>The optical simulation window</b></big><br>Use this window to perform optical simulations. Click on the play button to run a simulation."),"play.png",_("Click on the play button to run an optical simulation. The results will be displayed in the tabs to the right.")]) if self.optics_window==False: self.optics_window=class_optical() if self.optics_window.isVisible()==True: self.optics_window.hide() else: self.optics_window.show() def __init__(self): QWidget.__init__(self) self.rebuild_mat_list() self.doping_window=False self.cost_window=False self.optics_window=False self.main_vbox=QVBoxLayout() self.toolbar=QToolBar() self.toolbar.setIconSize(QSize(32, 32)) self.tb_add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add device layer"), self) self.tb_add.triggered.connect(self.on_add_item_clicked) self.toolbar.addAction(self.tb_add) self.tb_remove = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Delete device layer"), self) self.tb_remove.triggered.connect(self.on_remove_item_clicked) self.toolbar.addAction(self.tb_remove) self.tb_remove= QAction(QIcon(os.path.join(get_image_file_path(),"down.png")), _("Move device layer"), self) self.tb_remove.triggered.connect(self.on_move_down) self.toolbar.addAction(self.tb_remove) self.tb_doping = QAction(QIcon(os.path.join(get_image_file_path(),"doping.png")), _("Doping"), self) self.tb_doping.triggered.connect(self.callback_doping) self.toolbar.addAction(self.tb_doping) self.optics_button = QAction(QIcon(os.path.join(get_image_file_path(),"optics.png")), _("Optical simulation"), self) self.optics_button.triggered.connect(self.callback_optics_sim) self.toolbar.addAction(self.optics_button) self.tb_open = QAction(QIcon(os.path.join(get_image_file_path(),"organic_material.png")), _("Look at the materials database"), self) self.tb_open.triggered.connect(self.callback_view_materials) self.toolbar.addAction(self.tb_open) self.cost = QAction(QIcon(os.path.join(get_image_file_path(),"cost.png")), _("Calculate the cost of the solar cell"), self) self.cost.triggered.connect(self.callback_cost) self.toolbar.addAction(self.cost) self.main_vbox.addWidget(self.toolbar) self.tab = QTableWidget() self.tab.resizeColumnsToContents() self.tab.verticalHeader().setVisible(False) self.create_model() self.tab.cellChanged.connect(self.tab_changed) self.main_vbox.addWidget(self.tab) self.setLayout(self.main_vbox) def create_model(self): self.tab.clear() self.tab.setColumnCount(6) if enable_betafeatures()==False: self.tab.setColumnHidden(5, True) self.tab.setColumnHidden(4, True) self.tab.setSelectionBehavior(QAbstractItemView.SelectRows) self.tab.setHorizontalHeaderLabels([_("Layer name"), _("Thicknes"), _("Optical material"), _("Layer type"), _("DoS Layer"),_("PL Layer")]) self.tab.setRowCount(epitaxy_get_layers()) for i in range(0,epitaxy_get_layers()): thick=epitaxy_get_width(i) material=epitaxy_get_mat_file(i) dos_layer=epitaxy_get_electrical_layer(i) pl_file=epitaxy_get_pl_file(i) name=epitaxy_get_name(i) self.add_row(i,thick,material,dos_layer,pl_file,name) return def add_row(self,i,thick,material,dos_layer,pl_file,name): self.tab.blockSignals(True) dos_file="" if dos_layer.startswith("dos")==True: dos_file="active layer" else: dos_file=dos_layer item1 = QTableWidgetItem(str(name)) self.tab.setItem(i,0,item1) item2 = QTableWidgetItem(str(thick)) self.tab.setItem(i,1,item2) combobox = QComboBox() #combobox.setEditable(True) for a in self.material_files: combobox.addItem(str(a)) self.tab.setCellWidget(i,2, combobox) combobox.setCurrentIndex(combobox.findText(material)) p=combobox.palette() p.setColor(QPalette.Active, QPalette.Button, Qt.white); p.setColor(QPalette.Inactive, QPalette.Button, Qt.white); combobox.setPalette(p) #item3 = QTableWidgetItem(str(dos_file)) #self.tab.setItem(i,3,item3) combobox_layer_type = QComboBox() #combobox.setEditable(True) combobox_layer_type.addItem("contact") combobox_layer_type.addItem("active layer") combobox_layer_type.addItem("other") self.tab.setCellWidget(i,3, combobox_layer_type) combobox_layer_type.setCurrentIndex(combobox_layer_type.findText(str(dos_file).lower())) item3 = QTableWidgetItem(str(dos_layer)) self.tab.setItem(i,4,item3) item3 = QTableWidgetItem(str(pl_file)) self.tab.setItem(i,5,item3) scan_item_add("epitaxy.inp","#layer_material_file"+str(i),_("Material for ")+name,2) scan_item_add("epitaxy.inp","#layer_width"+str(i),_("Layer width ")+name,1) combobox.currentIndexChanged.connect(self.combo_changed) combobox_layer_type.currentIndexChanged.connect(self.layer_type_edit) self.tab.blockSignals(False) def clean_dos_files(self): files=inp_lsdir() tab=[] for i in range(0,self.tab.rowCount()): tab.append(str(tab_get_value(self.tab,i, 4))+".inp") for i in range(0,len(files)): if files[i].startswith("dos") and files[i].endswith(".inp"): disk_file=files[i] if disk_file not in tab: inp_remove_file(disk_file) def on_remove_item_clicked(self): tab_remove(self.tab) self.save_model() self.changed.emit() def change_active_layer_thickness(self,obj): thickness=obj.get_data("refresh") count=0 for item in self.model: if str2bool(item[COLUMN_DEVICE])==True: count=count+1 if count==1: for item in self.model: if str2bool(item[COLUMN_DEVICE])==True: item[COLUMN_THICKNES]=str(thickness) self.save_model() self.refresh(False) return def on_add_item_clicked(self): row=tab_insert_row(self.tab) self.add_row(row,"100e-9","pcbm","other","none","layer"+str(row)) self.save_model() self.changed.emit() def save_model(self): thick=[] mat_file=[] dos_file=[] pl_file=[] name=[] for i in range(0,self.tab.rowCount()): name.append(str(tab_get_value(self.tab,i, 0))) thick.append(str(tab_get_value(self.tab,i, 1))) mat_file.append(str(tab_get_value(self.tab,i, 2))) dos_file.append(str(tab_get_value(self.tab,i, 4))) pl_file.append(str(tab_get_value(self.tab,i, 5))) ret=epitaxy_load_from_arrays(name,thick,mat_file,dos_file,pl_file) if ret==False: error_dlg(self,_("Error in epitaxy, check the input values.")) epitaxy_save() self.clean_dos_files() #self.sync_to_electrical_mesh() def callback_doping(self): help_window().help_set_help(["doping.png",_("<big><b>Doping window</b></big>\nUse this window to add doping to the simulation")]) if self.doping_window==False: self.doping_window=doping_window() if self.doping_window.isVisible()==True: self.doping_window.hide() else: self.doping_window.show() def callback_cost(self): help_window().help_set_help(["cost.png",_("<big><b>Costs window</b></big>\nUse this window to calculate the cost of the solar cell and the energy payback time.")]) if self.cost_window==False: self.cost_window=cost() if self.cost_window.isVisible()==True: self.cost_window.hide() else: self.cost_window.show()