class ContentView(QWidget, ContentForm): set_current_page_signal = Signal(int) set_page_length_signal = Signal(int) def __init__(self, b_id, chap_id, page_num): super(ContentView, self).__init__() self.setupUi(self) self.b_id, self.chap_id = None, None self.page_list, self.page_len, self.page_num = None, None, None self.refresh(b_id, chap_id, page_num) def refresh(self, b_id, chap_id, page_num=None): self.b_id = b_id self.chap_id = chap_id self.page_num = page_num self.page_list = get_pages(b_id, chap_id) self.page_len = len(self.page_list) if self.page_num is None: self.page_num = 0 self.set_page_length_signal.emit(self.page_len) self.set_current_page_signal.emit(self.page_num) b_name = get_book('single', b_id)['name'] self.ChapterLabel.setText(f'## {b_name} -- Chapter {chap_id}') self.ContentTextEdit.setPlainText(self.page_list[self.page_num]) def get_page_info(self): return self.page_num, self.page_len def set_page(self, page_num): self.page_num = page_num self.ContentTextEdit.setPlainText(self.page_list[self.page_num])
class ControlBar(QtWidgets.QWidget): advance_day = Signal() reduce_day = Signal() current_day = Signal() def __init__(self,parent=None): super().__init__(parent) self.layout = QtWidgets.QHBoxLayout(self) #TODO can these buttons be styled better? self.prevButton = QtWidgets.QPushButton("Previous") self.nextButton = QtWidgets.QPushButton("Next") self.currentButton = QtWidgets.QPushButton("Current") ##assemble the controls self.layout.addWidget(self.prevButton) self.layout.addWidget(self.currentButton) self.layout.addWidget(self.nextButton) ## Wire up the signals self.prevButton.clicked.connect(self.previous_click) self.nextButton.clicked.connect(self.next_click) self.currentButton.clicked.connect(self.current_clicked) def previous_click(self): print("previous_clicked") self.reduce_day.emit() def next_click(self): print("next_clicked") self.advance_day.emit() def current_clicked(self): print("current_clicked") self.current_day.emit()
class RegisterView(QWidget, RegForm): submit_button_signal = Signal(type) display_status_signal = Signal(str, int) def __init__(self): super(RegisterView, self).__init__() self.setupUi(self) self.uid_empty = True self.psw_empty = True self.rep_psw_empty = True self.UidInput.textChanged.connect( lambda: self.button_enable_checker('uid')) self.PswInput.textChanged.connect( lambda: self.button_enable_checker('psw')) self.RepPswInput.textChanged.connect( lambda: self.button_enable_checker('rep_psw')) self.RegSubmitBtn.clicked.connect(self.submit_button_onclick) def button_enable_checker(self, val): assert val in {'uid', 'psw', 'rep_psw'} if val == 'uid': self.uid_empty = (self.UidInput.text() == '') elif val == 'psw': self.psw_empty = (self.PswInput.text() == '') else: self.rep_psw_empty = (self.RepPswInput.text() == '') flag = self.PswInput.text() == self.RepPswInput.text() self.RepPswChecker.setChecked(flag) self.RegSubmitBtn.setEnabled( (self.uid_empty or self.psw_empty or self.rep_psw_empty) is False and flag) def submit_button_onclick(self): uid = self.UidInput.text() psw = self.PswInput.text() email = self.EmailInput.text() data = { 'type': 'register', 'data': { 'uid': uid, 'psw': psw, 'email': email } } resp = get_response(data) assert resp['type'] == 'register' resp_data = resp['data'] if resp_data['status'] == 'ok': self.display_status_signal.emit('Successfully registered.', 3000) self.submit_button_signal.emit(LoginView) else: self.UidInput.clear() self.PswInput.clear() self.EmailInput.clear() self.RepPswInput.clear() self.display_status_signal.emit(resp_data['type'], 5000)
class CommunicationWorker(QObject): signal_get_ping_done = Signal(int, str, str) signal_post_history_done = Signal(str, bool) def __init__( self, netloc: str, base_path: str, api_key: str, guild: int, member: int ) -> None: super().__init__() self.client = EvelynClient(netloc=netloc, base_path=base_path, api_key=api_key) self.guild = guild self.member = member @Slot() def get_ping(self) -> None: try: key = -1 text = '' color = '' for ping in self.client.get_ping(guild=self.guild, member=self.member, filter_ping_due=False): key_ = ping['reminder']['key'] if key == -1 or key_ < key: key = key_ message = ping['message'] when = ping['when'] last = ping['last'] gaps = ping['gaps'] schedule = ping['schedule'] text = (f'<b>{message}</b><br>' f'<b>{when}</b><br>' f'<b>Last:</b> {last}<br>' f'<b>Gaps:</b> {gaps}<br>' f'<b>Schedule:</b> {schedule}') color = ping['reminder']['color_hex'] except Exception as e: key = -1 text = str(e) color = '#dd4b4b' self.signal_get_ping_done.emit(key, text, color) @Slot(int, QDateTime) def post_history( self, key: int, date_time: QDateTime ) -> None: try: data = self.client.post_history( guild=self.guild, member=self.member, key=key, time_utc=date_time.toPython() if date_time else None) text = str(data['message']) error = False except Exception as e: text = str(e) error = True self.signal_post_history_done.emit(text, error)
class get_file_hash_thread_work(QThread): signal1 = Signal(str, str) # 当前hash类型及hash结果 signal2 = Signal(str, str) # 当前hash类型及进度 def __init__(self, filename: str, hash_task: list[str], parent=None) -> None: super().__init__(parent=parent) self.filename = filename self.hash_task = hash_task def run(self): self.flag = 1 for key in self.hash_task: hashstr = hashlib.new(key) size = os.path.getsize(self.filename) hashed = 0 with open(self.filename, 'rb') as fileobj: while (tempdata := fileobj.read(40960)) != b"": if self.flag == 0: return hashstr.update(tempdata) hashed = hashed + 40960 rate = round(float(hashed) * 100 / size, 1) rate = min(rate, 100) rate = str(rate) + "%" self.signal2.emit(key, rate) self.signal1.emit(key, str(hashstr.hexdigest()))
class MouseEventMixin: mouse_left_press = Signal(QPoint) mouse_left_move = Signal(QPoint) mouse_left_release = Signal(QPoint) mouse_left_double_click = Signal(QMouseEvent) def __init__(self): pass def mousePressEvent(self, event): super(MouseEventMixin, self).mousePressEvent(event) if (event.button() == Qt.LeftButton): pos = event.globalPosition().toPoint() self.mouse_left_press.emit(pos) def mouseMoveEvent(self, event): super(MouseEventMixin, self).mouseMoveEvent(event) if (event.buttons() & Qt.LeftButton): pos = event.globalPosition().toPoint() self.mouse_left_move.emit(pos) def mouseReleaseEvent(self, event): super(MouseEventMixin, self).mouseReleaseEvent(event) if (event.button() == Qt.LeftButton): pos = event.globalPosition().toPoint() self.mouse_left_release.emit(pos) def mouseDoubleClickEvent(self, event): super(MouseEventMixin, self).mouseDoubleClickEvent(event) if (event.button() == Qt.LeftButton): self.mouse_left_double_click.emit(event)
class Worker(QThread): # 发出进度信号 updateValueSignal = Signal(int) # 发出文本信号 updateTextEditSignal = Signal(str, str) def __init__(self, dir, ext, prefix): super(Worker, self).__init__() self.dir = dir self.ext = ext self.prefix = prefix def run(self) -> None: """ The thread begins running from here. run() is only called after start() """ for (i, file) in enumerate(os.listdir(self.dir)): _, file_ext = os.path.splitext(file) if file_ext == self.ext: new_file_name = self.prefix + str(i) + self.ext src_path = os.path.join(self.dir, file) dst_path = os.path.join(self.dir, new_file_name) # os.rename(src, dst): src is original address of file to be renamed # and dst is destination location with new name. os.rename(src_path, dst_path) time.sleep(0.2) # Uncomment if process is too fasta and want to see the updates self.updateValueSignal.emit(i + 1) self.updateTextEditSignal.emit(file, new_file_name) else: pass # 运行结束后重置值 self.updateValueSignal.emit(0) # reset the value of the progress bar
class Communicate(QObject): speak_number = Signal(int) speak_word = Signal(str) def run(self): self.speak_number.emit(10) self.speak_word.emit("Hello everybody!")
class MctsWorker(QObject): move_chosen = Signal(int) # board, analysing_player, [(move_text, probability, count)] for top 10 choices move_analysed = Signal(GameState, int, list) def __init__(self, player: MctsPlayer, parent: QObject = None): super().__init__(parent) self.player = player @Slot(int, GameState) # type: ignore def choose_move(self, active_player: int, game_state: GameState): # noinspection PyBroadException try: if self.player.player_number != active_player: return move = self.player.choose_move(game_state) # noinspection PyUnresolvedReferences self.move_chosen.emit(move) # type: ignore except Exception: print_exc() message = QMessageBox() message.setWindowTitle('Error') message.setText(f'Failed to choose a move.') message.exec_() @Slot(GameState) # type: ignore def analyse_move(self, game_state: GameState): move_probabilities = self.player.get_move_probabilities(game_state) # noinspection PyUnresolvedReferences self.move_analysed.emit(game_state, # type: ignore self.player.player_number, move_probabilities)
class RenderSongWorker(QObject): finished = Signal(bool) error = Signal(str) progress = Signal(str) def __init__(self, song: SongTreeWidgetItem): super().__init__() self.song = song def run(self): try: command_str = (self.song.get("commandString")).format(**self.song.to_dict()) handler = ProcessHandler() handler.stderr.connect(self.error.emit) handler.stdout.connect(self.progress.emit) errors = handler.run(command_str) if not errors: # cut video to exact length of song handler = ProcessHandler() handler.stderr.connect(self.error.emit) handler.stdout.connect(self.progress.emit) command_str = 'ffmpeg -loglevel error -progress pipe:1 -y -i "{tempFileOutput}" -t {songDuration} -acodec copy -vcodec copy "{fileOutput}"'.format(**self.song.to_dict()) errors = handler.run(command_str) os.remove(self.song.get("tempFileOutput")) self.finished.emit(not errors) except Exception as e: self.error.emit(traceback.format_exc()) self.finished.emit(False) def get_duration_ms(self): return self.song.get_duration_ms() def __str__(self): return self.song.get("fileOutput")
class OptionalCurrencyComboBox(QWidget): changed = Signal() name_updated = Signal(str) def __init__(self, parent): QWidget.__init__(self, parent) self._id = 0 self.layout = QHBoxLayout() self.layout.setContentsMargins(0, 0, 0, 0) self.null_flag = QCheckBox(parent) self.null_flag.setChecked(False) self.null_flag.setText(self.tr("Currency")) self.layout.addWidget(self.null_flag) self.currency = CurrencyComboBox(parent) self.currency.setEnabled(False) self.layout.addWidget(self.currency) self.setLayout(self.layout) self.setFocusProxy(self.null_flag) self.null_flag.clicked.connect(self.onClick) self.currency.changed.connect(self.onCurrencyChange) def setText(self, text): self.null_flag.setText(text) def getId(self): return self._id if self._id else None def setId(self, new_value): if self._id == new_value: return self._id = new_value self.updateView() name = JalDB().get_asset_name(self._id) self.name_updated.emit('' if name is None else name) currency_id = Property(int, getId, setId, notify=changed, user=True) def updateView(self): has_value = True if self._id else False if has_value: self.currency.selected_id = self._id self.null_flag.setChecked(has_value) self.currency.setEnabled(has_value) @Slot() def onClick(self): if self.null_flag.isChecked(): if self.currency.selected_id == 0: self.currency.selected_id = JalSettings().getValue('BaseCurrency') self.currency_id = self.currency.selected_id else: self.currency_id = 0 self.changed.emit() @Slot() def onCurrencyChange(self, _id): self.currency_id = self.currency.selected_id self.changed.emit()
class MainWindow(QObject): def __init__(self): QObject.__init__(self) # Static Info staticUser = "******" staticPass = "******" # Signals To Send Data signalUser = Signal(str) signalPass = Signal(str) signalLogin = Signal(bool) # Function To Check Login @Slot(str, str) def checkLogin(self, getUser, getPass): if (self.staticUser.lower() == getUser.lower() and self.staticPass == getPass): # Send User And Pass self.signalUser.emit("Username: "******"Password: "******"Login passed!") else: self.signalLogin.emit(False) print("Login error!")
class WelcomeView(QWidget, WelcomeForm): select_book_signal = Signal(type) display_status_signal = Signal(str, int) set_current_book_signal = Signal(int) def __init__(self): super(WelcomeView, self).__init__() self.setupUi(self) self.has_clicked = False book_list = get_book('all') for book in book_list: book_item = BookListItem(book['book_id'], book['name']) self.BookListWidget.addItem(book_item) self.BookListWidget.itemClicked.connect(self.item_onclick) self.BookListWidget.itemDoubleClicked.connect(self.item_onclick_double) def item_onclick_double(self, item): self.set_current_book_signal.emit(item.b_id) self.select_book_signal.emit(ChapterView) def item_onclick(self, item): synopsis_text = self.SynopsisTextEdit.toPlainText() if not self.has_clicked: self.has_clicked = True else: index = synopsis_text.find('\n\n') synopsis_text = synopsis_text[index + 2:] self.SynopsisTextEdit.setPlainText(item.text() + '\n\n' + synopsis_text)
class GenericWorker(QObject): """Generic worker thread object which can broadcast messages""" message = Signal(MessageType, str) exit_on_error = Signal() def run(self): """Base method to run and post exceptions as errors""" try: self.run_impl() except Exception as exc: self.post_error(f'Thread exited with "{exc}"') self.exit_on_error.emit() raise def post_debug(self, text): """Broadcast debug messages to anyone listening""" self.message.emit(MessageType.DEBUG, text) def post_error(self, text): """Broadcast error messages to anyone listening""" self.message.emit(MessageType.ERROR, text) def post_generic(self, text): """Broadcast messages to anyone listening""" self.message.emit(MessageType.GENERIC, text)
class WorkerSignals(QtCore.QObject): """ Defines signals avaliable from a worker thread. - dataframe_result: pandas dataframe data returned from processing. - error: error information """ dataframe_result: Signal = Signal(pd.DataFrame) error: Signal = Signal(str)
class ConnectKeyboard(QThread): found = Signal(str) connected = Signal(BluetoothSocket) def run(self): config = Config() keyboardAddr = config.get('addr') or find_keyboard() self.found.emit(keyboardAddr) sock = connect_keyboard(keyboardAddr) self.connected.emit(sock)
class Statements(QObject): load_completed = Signal(int, defaultdict) load_failed = Signal() def __init__(self, parent): super().__init__() self.parent = parent self.items = [] self.loadStatementsList() def loadStatementsList(self): statements_folder = get_app_path() + Setup.IMPORT_PATH + os.sep + Setup.STATEMENT_PATH statement_modules = [filename[:-3] for filename in os.listdir(statements_folder) if filename.endswith(".py")] for module_name in statement_modules: logging.debug(f"Trying to load statement module: {module_name}") module = importlib.import_module(f"jal.data_import.broker_statements.{module_name}") try: statement_class_name = getattr(module, "JAL_STATEMENT_CLASS") except AttributeError: continue try: class_instance = getattr(module, statement_class_name) except AttributeError: logging.error(self.tr("Statement class can't be loaded: ") + statement_class_name) continue statement = class_instance() self.items.append({ 'name': statement.name, 'module': module, 'loader_class': statement_class_name, 'icon': statement.icon_name, 'filename_filter': statement.filename_filter }) logging.debug(f"Class '{statement_class_name}' providing '{statement.name}' statement has been loaded") self.items = sorted(self.items, key=lambda item: item['name']) # method is called directly from menu, so it contains QAction that was triggered def load(self, action): statement_loader = self.items[action.data()] statement_file, active_filter = QFileDialog.getOpenFileName(None, self.tr("Select statement file to import"), ".", statement_loader['filename_filter']) if not statement_file: return module = statement_loader['module'] class_instance = getattr(module, statement_loader['loader_class']) statement = class_instance() try: statement.load(statement_file) statement.validate_format() statement.match_db_ids() totals = statement.import_into_db() except Statement_ImportError as e: logging.error(self.tr("Import failed: ") + str(e)) self.load_failed.emit() return self.load_completed.emit(statement.period()[1], totals)
class TrieView(QTreeView): linkUnhovered = Signal() linkHovered = Signal(str) linkActivated = Signal(str) def __init__(self, *args, **kwargs): super(TrieView, self).__init__(*args, **kwargs) self.setMouseTracking(True) self._mousePressAnchor = '' self._lastHoveredAnchor = '' def mousePressEvent(self, event): super(TrieView, self).mousePressEvent(event) anchor = self.anchorAt(event.pos()) self._mousePressAnchor = anchor def mouseMoveEvent(self, event): anchor = self.anchorAt(event.pos()) if self._mousePressAnchor != anchor: self._mousePressAnchor = '' if self._lastHoveredAnchor != anchor: self._lastHoveredAnchor = anchor if self._lastHoveredAnchor: QApplication.setOverrideCursor(QCursor(Qt.PointingHandCursor)) self.linkHovered.emit(self._lastHoveredAnchor) else: QApplication.restoreOverrideCursor() self.linkUnhovered.emit() def mouseReleaseEvent(self, event): if self._mousePressAnchor: anchor = self.anchorAt(event.pos()) if anchor == self._mousePressAnchor: self.linkActivated.emit(self._mousePressAnchor) self._mousePressAnchor = '' super(TrieView, self).mouseReleaseEvent(event) def anchorAt(self, pos): index = self.indexAt(pos) if index.isValid(): delegate = self.itemDelegate(index) wordDelegate = delegate if isinstance(wordDelegate, CalleesDelegate): itemRect = self.visualRect(index) relativeClickPosition = pos - itemRect.topLeft() html = index.data() if html is not None: return wordDelegate.anchorAt(html, relativeClickPosition) return ''
class WorkerSignals(QObject): """ Defines the signals available from a running worker thread. progress int progress complete,from 0-100 """ progress = Signal(str, int) finished = Signal(str)
class Worker(QObject): finished = Signal() progress = Signal(int) def run(self): """耗时任务""" for i in range(5): sleep(1) self.progress.emit(i + 1) self.finished.emit()
class VideoLoader(QThread): sig_start = Signal(int) sig_progress = Signal(int, int, str) sig_frame_finished = Signal(int, bytes, dict) sig_all_finished = Signal() def __init__(self, settings: Settings, parent=None): super(VideoLoader, self).__init__(parent) self.settings = settings self.video_data = VideoData() self.vid = None self.analyzer = Analyzer(settings, self) def set_file(self, file_path: str) -> VideoData: self.video_data.file_path = file_path self.vid = cv2.VideoCapture(file_path) self.video_data.width = int(self.vid.get(cv2.CAP_PROP_FRAME_WIDTH)) self.video_data.height = int(self.vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) self.video_data.fps = int(self.vid.get(cv2.CAP_PROP_FPS)) self.video_data.frame_count = int( self.vid.get(cv2.CAP_PROP_FRAME_COUNT)) return self.video_data def run(self): self.sig_start.emit(self.video_data.frame_count) if self.vid is None: QMessageBox.warning(self.parent(), '错误', '未选择文件') return frame_index = 0 while True: ret, frame = self.vid.read() if not ret: break color_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) frame_index += 1 origin_h, origin_w, ch = frame.shape img = QImage(frame.data, origin_w, origin_h, ch * origin_w, QImage.Format_BGR888) base64 = self.image_to_base64(img) frame_particles = self.analyzer.analyze(frame_index, color_frame) self.sig_progress.emit(self.video_data.frame_count, frame_index, self.tr(constant.status_reading)) self.sig_frame_finished.emit(frame_index, base64, frame_particles) self.sig_all_finished.emit() def image_to_base64(self, img: QImage) -> bytes: quality = self.settings.int_value(default_settings.frame_quality) byte_arr = QByteArray() buffer = QBuffer(byte_arr) buffer.open(QIODevice.WriteOnly) img.save(buffer, 'jpg', quality) return byte_arr.toBase64().data()
def switch_slot(signal: Signal, new: Callable) -> None: """シグナルのスロット切り替え Parameters ---------- signal: Signal スロットを切り替えするシグナル new: Callable 新しく接続するシグナル """ signal.disconnect() signal.connect(new)
class CheckApps(QThread): """Refresh list of installed apps.""" progress_signal = Signal() app_signal = Signal(object) def __init__(self, apps_dict): super().__init__() self.apps_dict = apps_dict def run(self): si = subprocess.STARTUPINFO() si.dwFlags |= subprocess.STARTF_USESHOWWINDOW x = subprocess.Popen([ "powershell", "Get-AppxPackage -PackageTypeFilter Main | Select Name, InstallLocation | ConvertTo-JSON" ], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, shell=False, startupinfo=si, text=True) names_str = x.communicate()[0] names_list = json.loads(names_str) for i in self.apps_dict: temp_name = self.apps_dict[i]["name"].strip("*") self.apps_dict[i]["size"] = 0 flag = False if temp_name != "Xbox": for item in names_list: name = item["Name"] if name.find(temp_name, 0, len(name)) != -1: flag = True self.apps_dict[i]["size"] += get_dir_size( item["InstallLocation"]) / 1024 / 1024 break else: for item in names_list: name = item["Name"] if name.find(temp_name, 0, len(name)) != -1 and name.find( "XboxGameCallableUI", 0, len(name)) == -1: flag = True self.apps_dict[i]["size"] += get_dir_size( item["InstallLocation"]) / 1024 / 1024 if flag: self.app_signal.emit(i) self.progress_signal.emit()
class ProjectTabs(QWidget): sg_prj_page_selc = Signal(int) # int: page number sg_prj_save = Signal() def __init__(self, parent=None): super().__init__(parent=parent) pal = self.palette() pal.setColor(QPalette.ColorRole.Window, QColor(247, 247, 247)) self.setAutoFillBackground(True) self.setPalette(pal) wcb_page_selc = QComboBox() wcb_page_selc.currentTextChanged.connect(self._sl_page_selc_change) wcb_page_selc.addItem("Home") wcb_page_selc.addItem("Models") wcb_page_selc.addItem("Execution") wcb_page_selc.addItem("Deployment") lyt_main = QHBoxLayout() lyt_main.addWidget(wcb_page_selc) wb_save_proj = QPushButton("Save Project") wb_save_proj.clicked.connect(self._sl_proj_save_click) lyt_main.addWidget(wb_save_proj) lyt_main.addWidget(QPushButton("Press me! (Does nothing)")) self.setLayout(lyt_main) margin = lyt_main.contentsMargins() margin.setTop(3) margin.setBottom(3) lyt_main.setContentsMargins(margin) @Slot(str) def _sl_page_selc_change(self, text): try: page_no = { "Home": 0, "Models": 1, "Execution": 2, "Deployment": 3 }[text] except KeyError: print(f"error: <{text}> page not implemented") page_no = 0 self.sg_prj_page_selc.emit(page_no) @Slot(bool) def _sl_proj_save_click(self, _checked): self.sg_prj_save.emit()
class OptWorker(QObject): working_signal = Signal() update_signal = Signal() finished_signal = Signal() def __init__(self, optimiser: BayesOptimiser): self.optimiser = optimiser self.window = None super(OptWorker, self).__init__() def suggest_bayes_steps(self): self.working_signal.emit() self.optimiser.suggest_bayes_steps() self.finished_signal.emit() def do_opt_steps(self): self.run_opt_step() while self.window.ui.checkBox_keep_running.checkState() \ and self.optimiser.current_point < self.optimiser.n_points: self.run_opt_step() self.finished_signal.emit() def run_opt_step(self): self.working_signal.emit() self.optimiser.run_opt_step() self.update_signal.emit() def refit_model(self): self.working_signal.emit() self.optimiser.refit_model() self.finished_signal.emit() def renormalise_model(self): self.working_signal.emit() self.optimiser.renormalise() self.optimiser.refit_model() self.finished_signal.emit()
class ClassFilterProxyModel(QSortFilterProxyModel, QObject): _changed_front_page_ = Signal(bool) _changed_filter_class_ = Signal(str) _front_page_ = True _filter_class_ = 'all' def __init__(self): super().__init__() def get_front_page(self): return self._front_page_ def set_front_page(self, fp): if self._front_page_ != fp: self._front_page_ = fp self._changed_front_page_.emit(self._front_page_) self.invalidateFilter() def get_filter_class(self): return self._filter_class_ def set_filter_class(self, new_filter): if self._filter_class_ != new_filter: # _logger.debug(f'class filter: set_filter_class {new_filter}') self._filter_class_ = new_filter self._changed_filter_class_.emit(self._filter_class_) self.invalidateFilter() front_page = Property(bool, get_front_page, set_front_page, notify=_changed_front_page_) filter_class = Property(str, get_filter_class, set_filter_class, notify=_changed_filter_class_) def filterAcceptsRow(self, source_row, source_parent: QModelIndex): index = self.sourceModel().index(source_row, 0, source_parent) if self.front_page: return True else: if self._filter_class_ == 'all': return True else: device_class_id = index.data(DeviceRoles.DEVICE_CLASS_ID) cb_filter = device_class_id == self._filter_class_ return cb_filter
class set_list_thread_work(QThread): signal_fun = Signal(dict) signal_state = Signal(str) def __init__(self, vm_name) -> None: super().__init__() self.vm_name = vm_name def run(self): vm_state = get_vm_state(self.vm_name) self.signal_state.emit(vm_state) fun_dict = {} fun_dict.update(get_vmprocessor(self.vm_name)) self.signal_fun.emit(fun_dict)
class VideoThread(QObject): change_pixmap_signal = Signal(np.ndarray) update_fps_signal = Signal(float) def __init__(self, filter_list): super().__init__() self._fps = fps.FPS() self._run_flag = True self.filter_list = filter_list self.cap = cv2.VideoCapture(0) self._ind = 0 self.video_loop = VideoLoopBack() @Slot() def new_filter_slot(self, ind): self._ind = ind logger.debug(f'ind {ind}') @Slot() def start(self): print('start') self._fps.start() while self._run_flag: ret, cv_img = self.cap.read() if ret: fimg = self.filter_list[self._ind][1].process(cv_img) logger.debug(cv_img.shape) self.video_loop.new_image(fimg) self.change_pixmap_signal.emit(fimg) self._fps.update() self.update_fps_signal.emit(self._fps.fps) logger.info('Stopping thread') self.video_loop.process2.stdin.close() self.video_loop.process2.terminate() logger.debug('Video writer closed') self.cap.release() logger.debug('Capture device closed') @Slot() def pause(self): print('pause') self._run_flag = False def stop(self): """Sets run flag to False and waits for thread to finish""" self._run_flag = False logger.debug('Stop Ran')
class WindowDragger(QWidget): """ Window dragger. Args: window (QWidget): Associated window. parent (QWidget, optional): Parent widget. """ doubleClicked = Signal() def __init__(self, window, parent=None): QWidget.__init__(self, parent) self._window = window self._mousePressed = False def mousePressEvent(self, event): self._mousePressed = True self._mousePos = event.globalPos() self._windowPos = self._window.pos() def mouseMoveEvent(self, event): if self._mousePressed: self._window.move(self._windowPos + (event.globalPos() - self._mousePos)) def mouseReleaseEvent(self, event): self._mousePressed = False def mouseDoubleClickEvent(self, event): self.doubleClicked.emit()
class EditAnnotationDialog(QDialog): annotation_changed = Signal(Annotation) def __init__(self, parent, annotation: Annotation) -> None: super().__init__(parent=parent) self.ui = Ui_EditAnnotationDialog() self.ui.setupUi(self) self.rom_variant = annotation.rom_variant self.ui.lineEditVariant.setText(annotation.rom_variant) self.ui.lineEditAddress.setText(hex(annotation.address)) self.ui.spinBoxLength.setValue(annotation.length) self.ui.lineEditColor.setText(annotation.color.name()) self.ui.lineEditAuthor.setText(annotation.author) self.ui.plainTextEditNote.setPlainText(annotation.note) self.accepted.connect(self.on_accept) def get_annotation(self) -> Annotation: return Annotation(RomVariant(self.ui.lineEditVariant.text()), parse_address(self.ui.lineEditAddress.text()), self.ui.spinBoxLength.value(), QColor(self.ui.lineEditColor.text()), self.ui.lineEditAuthor.text(), self.ui.plainTextEditNote.toPlainText().strip()) def on_accept(self) -> None: self.annotation_changed.emit(self.get_annotation())