def __init__(self): super().__init__() # Título da janela. self.setWindowTitle('PySide2 QProgressDialog().') # Ícone da janela principal icon = QIcon() icon.addPixmap(QPixmap('../../../images/icons/icon.png')) self.setWindowIcon(icon) # Tamanho inicial da janela. screen_size = app.desktop().geometry() # screen_size = app.primaryScreen().geometry() width = screen_size.width() height = screen_size.height() self.resize(width / 2, height / 2) # Tamanho mínimo da janela. self.setMinimumSize(width / 2, height / 2) # Tamanho maximo da janela. self.setMaximumSize(width - 200, height - 200) # Widget central. widget = QWidget() self.setCentralWidget(widget) # Widgets. vbox = QVBoxLayout() widget.setLayout(vbox) self.label = QLabel( 'A janela de processo irá abrir sozinha quando o evento do' 'timer (QTimer) for iniciado.\n' 'Ao clicar no botão cancelar o evento é interrompido.\n' 'Quando o diálogo de progresso atinge o maximo o envento é ' 'interrompido.', ) self.label.setAlignment(Qt.AlignCenter) vbox.addWidget(self.label) button = QPushButton('Abrir diálogo novamente') button.clicked.connect(self.start_progress_again) vbox.addWidget(button) self.progress_dialog = QProgressDialog( parent=self, labelText=( 'Ao clicar em cancelar o timer (QTimer) será parado e a barra ' 'de progresso é reiniciada.'), cancelButtonText='Cancelar', minimum=0, maximum=100, ) self.progress_dialog.setWindowTitle('Titulo da janela de diálogo') self.progress_dialog.setModal(True) self.progress_dialog.canceled.connect(self.stop_progress) self.timer = QTimer() self.timer.timeout.connect(self.start_progress) self.timer.start(1000)
def generatePrediction(self): self.method_name = self.choose_method.currentText() self.prediction_length = self.choose_prediction_length.value() form_treatments = sorted( [ Treatment(0, t_date.date().toPython(), 1) for t_date in self.treatments ], key=attrgetter("date"), ) treatments = self.patient.treatments + form_treatments self.accept() self.progress_bar = QProgressBar() self.progress_bar.setRange(0, 0) self.progress_dialog = QProgressDialog( f"Generowanie predykcji za pomocą {self.method_name}", None, 0, 1) self.progress_dialog.setWindowFlags(Qt.Dialog | Qt.FramelessWindowHint) self.progress_dialog.setWindowModality(Qt.WindowModal) self.progress_dialog.setBar(self.progress_bar) prediction_fun = self.name_to_impl[self.method_name] self.progress_dialog.show() self.runnable = PredictionRunnable( prediction_fun, self.patient.measurements, self.prediction_length, treatments, ) self.runnable.result.connect(self.handlePrediction) self.runnable.start()
def add_app_ui(self, manifests: List[str]): def on_progress(value): if value != self.app_progress.maximum(): return self.add_app_thread.progress.disconnect(on_progress) del self.app_progress del self.add_app_thread def on_failed(exc_info): msg = QMessageBox( QMessageBox.Critical, "Fail to add application", f"Failed to add application: \n\n{exc_info[0].__name__}: {exc_info[1]}", ) msg.setDetailedText("".join(traceback.format_exception(*exc_info))) msg.exec_() self.app_progress = QProgressDialog("Installing app", "Cancel", 0, 100) self.add_app_thread = _FetchRegistryThread(self, apps=manifests) self.add_app_thread.progress.connect(self.app_progress.setValue) self.add_app_thread.progress.connect(on_progress) self.add_app_thread.items.connect(self.app_progress.setMaximum) self.add_app_thread.label.connect(self.app_progress.setLabelText) self.add_app_thread.failed.connect(on_failed) self.app_progress.canceled.connect(self.add_app_thread.cancel) self.add_app_thread.start() self.app_progress.exec_()
def openProject(self, filename=None): if not filename: (filename, ftype) = QFileDialog.getOpenFileName( self, "Choose project file", dir=self.lastProjectDirectory, filter="Projects (*.prj)", options=QFileDialog.DontResolveSymlinks | QFileDialog.HideNameFilterDetails) if filename: self.lastProjectDirectory = str(Path(filename).parent) self.createProject() progress = QProgressDialog('', None, 0, 100, self) try: self.project.load(filename, progress) self.lastProjectFile = filename if filename in self.recentProjectFiles: self.recentProjectFiles.remove(filename) self.recentProjectFiles.insert(0, filename) self.updateRecentMenu() self.updateShaderMenu() self.editor.setProject(self.project) self.saveSettings() except BaseException as e: progress.close() raise e
def _init_statusbar(self): self._progressbar = QProgressBar() self._progressbar.setMinimum(0) self._progressbar.setMaximum(100) self._progressbar.hide() self.statusBar().addPermanentWidget(self._progressbar) self._progress_dialog = QProgressDialog("Waiting...", "Cancel", 0, 100, self) self._progress_dialog.setAutoClose(False) self._progress_dialog.setWindowFlags( self._progress_dialog.windowFlags() & ~Qt.WindowContextHelpButtonHint) self._progress_dialog.setModal(True) self._progress_dialog.setMinimumDuration(2**31 - 1) def on_cancel(): if self.workspace is None: return for job in self.workspace.instance.jobs: if job.blocking: job.keyboard_interrupt() break self._progress_dialog.canceled.connect(on_cancel) self._progress_dialog.close()
def preselect(self): progress = QProgressDialog('', None, 0, 100, self) try: self.project.preselect(progress) except BaseException as e: progress.close() raise e
def load_default_apps(self): def on_progress(value): if value != self.default_app_progress.maximum(): return self.settings.setValue("apps/_meta/isDefaultLoaded", True) logger.info("Default apps loaded") self.default_app_thread.progress.disconnect(on_progress) del self.default_app_progress del self.default_app_thread self.default_app_progress = QProgressDialog("Loading default apps", "Cancel", 0, 100) self.default_app_thread = _FetchRegistryThread(self) self.default_app_thread.progress.connect( self.default_app_progress.setValue) self.default_app_thread.progress.connect(on_progress) self.default_app_thread.items.connect( self.default_app_progress.setMaximum) self.default_app_thread.label.connect( self.default_app_progress.setLabelText) self.default_app_progress.canceled.connect( self.default_app_thread.cancel) self.default_app_thread.start() self.default_app_progress.show()
def __init__(self): super(MainWindow, self).__init__() # Caminho até o arquivo de interface. # path = QDir(__file__).currentPath() # ui_file = QDir(path).filePath('MainWindow.ui') ui_file = QDir(QDir(__file__).currentPath()).filePath('MainWindow.ui') self.ui = QUiLoader().load(ui_file, None) # Widgets. self.label = self.ui.findChild(QObject, 'label') button = self.ui.findChild(QObject, 'button') button.clicked.connect(self.start_progress_again) self.progress_dialog = QProgressDialog( parent=self.ui, labelText=( 'Ao clicar em cancelar o timer (QTimer) será parado e a barra ' 'de progresso é reiniciada.' ), cancelButtonText='Cancelar', minimum=0, maximum=100, ) self.progress_dialog.setWindowTitle('Titulo da janela de diálogo') self.progress_dialog.setModal(True) self.progress_dialog.canceled.connect(self.stop_progress) self.timer = QTimer() self.timer.timeout.connect(self.start_progress) self.timer.start(1000) self.ui.show()
def send_program(self): selections = self.ui.programListWidget.selectedItems() for selection in selections: filename = selection.text() filepath = self.dir.path() + '/' + filename port_chosen = self.ui.serialPortChooser.currentText() confirm = ConfirmSend(self) confirm.ui.dialogLabel.setText(f'Send program \'{filename}\'?') confirm.exec() if confirm.result() == QDialog.Accepted: self.send_status = QProgressDialog(self) self.sender = Sender( port_chosen, filepath, globalSettings.value('serialport/baudrate'), globalSettings.value('serialport/databits'), globalSettings.value('serialport/parity'), globalSettings.value('serialport/stopbits'), globalSettings.value('serialport/flowcontrol'), self) self.send_status.setMaximum(self.sender.file.size()) self.send_status.canceled.connect(self.sender.cancel) self.sender.signals.update_status.connect( self.send_status.setValue) self.thread_pool.start(self.sender) self.send_status.exec_() self.send_status.deleteLater()
def prepare(self): modelfile = 'models/median_b{}.mdl'.format(self.block) try: model = load(modelfile) except FileNotFoundError: QMessageBox.critical( self, self.tr('Error'), self.tr('Model not found ("{}")!'.format(modelfile))) return limit = model.best_ntree_limit if hasattr(model, 'best_ntree_limit') else None columns = model._features_count if columns == 8: levels = 1 windows = 1 elif columns == 24: levels = 3 windows = 1 elif columns == 96: levels = 3 windows = 4 elif columns == 128: levels = 4 windows = 4 else: QMessageBox.critical(self, self.tr('Error'), self.tr('Unknown model format!')) return padded = pad_image(self.gray, self.block) rows, cols = padded.shape self.prob = np.zeros( ((rows // self.block) + 1, (cols // self.block) + 1)) self.var = np.zeros_like(self.prob) progress = QProgressDialog(self.tr('Detecting median filter...'), self.tr('Cancel'), 0, self.prob.size, self) progress.canceled.connect(self.cancel) progress.setWindowModality(Qt.WindowModal) k = 0 self.canceled = False for i in range(0, rows, self.block): for j in range(0, cols, self.block): roi = padded[i:i + self.block, j:j + self.block] x = np.reshape(get_features(roi, levels, windows), (1, columns)) y = model.predict_proba(x, ntree_limit=limit)[0, 1] ib = i // self.block jb = j // self.block self.var[ib, jb] = np.var(roi) self.prob[ib, jb] = y if self.canceled: self.prob = self.var = None progress.close() return progress.setValue(k) k += 1 progress.close() self.process()
def massive_merge(self): # Comprueba si la carpeta de destino y la carpeta de origen son válidas # Carga los nombres en partes y los nombres de archivo completos if path.isdir(self.source_folder.text()) and path.isdir( self.dest_folder.text()): splitted_names, pdf_files = self.load_files( self.source_folder.text()) # Toma el orden de los archivos desde la lista del pdf_order_widget order_list = [ str(self.pdf_order_widget.item(i).text()) for i in range(self.pdf_order_widget.count()) ] print(f'order list: {order_list}') if order_list: # toma la lista con los números de póliza únicamente polizas = list(set([x[0] for x in splitted_names])) print(f'polizas : {polizas}') progress = QProgressDialog("Unificando archivos...", "Abortar", 0, len(polizas), self) progress.setWindowModality(Qt.WindowModal) try: for poliza in polizas: progress.setValue(polizas.index(poliza)) pdf_merger = PdfWriter() for part in order_list: pattern = str(poliza + "[_\s]" + part + ".*") r = re.compile(pattern) file_name = list(filter(r.match, pdf_files)) print(f'file_name: {file_name}') if file_name: fullfile_name = path.join( self.source_folder.text(), file_name[0]) pdf_merger.addpages( PdfReader(fullfile_name).pages) file_dest = path.join(self.dest_folder.text(), '.'.join([poliza, 'pdf'])) print(f'file dest: {file_dest}') pdf_merger.write(file_dest) # pdf_merger.close() if progress.wasCanceled(): break progress.setValue(len(polizas)) self.dialog_message( 'La Unificación masiva ha concluído con éxito!', QMessageBox.Information) except Exception as e: self.dialog_message(str(e), QMessageBox.Warning) else: self.dialog_message( 'La lista con el orden de las partes está vacía, por favor cargue los archivos!', QMessageBox.Warning) else: self.dialog_message( 'La carpeta de origen o destino es inválida, ' 'Por favor ingrese carpetas válidas!', QMessageBox.Warning)
def _download_progress_callback(self, total, so_far): if not self._download_progress_dialog: self._download_progress_dialog = QProgressDialog( _("Downloading the selected database."), None, 0, 100, self) self._download_progress_dialog.setWindowTitle( _("Download in progress")) percentage = int((so_far / total) * 100) self._download_progress_dialog.setLabelText( _("Downloading the selected database. Downloaded {so_far} of {total}." ).format(so_far=format_size(so_far), total=format_size(total))) self._download_progress_dialog.setValue(percentage)
def __init__(self, title, description, max_value): QProgressDialog.__init__(self) self.setWindowTitle(title) self.setLabelText(description) self.setMaximum(max_value) self.setWindowModality(Qt.ApplicationModal) self.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint) self.setFixedSize(self.size()) self.setAutoReset(False) self.setCancelButton(None) self.show()
def exportViews(self): filename, ok = QInputDialog.getText(self, "View Image Filename", "Png filename") if ok and len(filename) > 0: progress = QProgressDialog('', None, 0, 100, self) try: self.project.exportviews(self.view.context(), filename, progress) except BaseException as e: progress.close() raise e
def __init_progress(self, steps: int): """__init_progress will init the progress bar Arguments: steps {int} -- Number of step of the progress bar """ self.progress = QProgressDialog('Operation in progress.', 'Stop', 0, steps) self.progress_start = 0 self.progress.setMinimumWidth(400) self.progress.setMinimumHeight(100) self.progress.show()
def load_dataList(self, nameList, showThumbnail=True, progressBar=True): self.dataList.clear() if progressBar: progress = QProgressDialog("Loading data...", "Abort", \ 0, len(nameList), self.window) progress.setWindowModality(Qt.WindowModal) for i, dataName in enumerate(nameList): newItem = QtWidgets.QListWidgetItem(dataName) # Mark finished data if self.in_task and (dataName in self.current_task.finished_data): newItem.setBackground(QBrush(QColor("#b3b3b3"))) if showThumbnail: # boring img down sizing and img format converting img = Image.open(self.current_data_dir + IMG_FOLDER \ + '/' + dataName + '.' + IMG_EXT) w, h = img.size img = img.resize((128, int(128 * h / w))) img = img.convert("RGBA") qimg = QImage(img.tobytes('raw', 'RGBA'), img.size[0], \ img.size[1], QImage.Format_RGBA8888) thumbnail = QIcon() thumbnail.addPixmap(QtGui.QPixmap.fromImage(qimg)) newItem.setIcon(thumbnail) # pre load all the labels label_dir = self.current_data_dir + LEBEL_FOLDER \ + '/' + dataName + '.txt' if os.path.exists(label_dir): with open(label_dir, 'r') as label_file: bboxs = [] for line in label_file: bbox_l = line.split() class_num = int(bbox_l[0]) centerX = int(float(bbox_l[1]) * w) centerY = int(float(bbox_l[2]) * h) width = int(float(bbox_l[3]) * w) height = int(float(bbox_l[4]) * h) new_bbox = BBox([centerX, centerY, width, height],\ [w, h], class_num) bboxs.append(new_bbox) label_table[dataName] = bboxs else: # self.error_msg("Cannot find label: " + \ # label_dir) # if the label do not exist, create an empty bbox list bboxs = [] label_table[dataName] = bboxs self.dataList.addItem(newItem) if progressBar: progress.setValue(i) if progress.wasCanceled(): break if progressBar: progress.setValue(len(nameList))
def save_animation(self): if self.last_result is not None: filename, format_str = self.file_dialog.getSaveFileName(self, self.tr("Save the animation of this SSU result"), None, self.tr("MPEG-4 Video File (*.mp4);;Graphics Interchange Format (*.gif)")) if filename is None or filename == "": return progress = QProgressDialog(self) progress.setRange(0, 100) progress.setLabelText(self.tr("Saving Animation [{0} Frames]").format(self.last_result.n_iterations)) canceled = False def save_callback(i, n): if progress.wasCanceled(): nonlocal canceled canceled = True raise StopIteration() progress.setValue((i+1)/n*100) QCoreApplication.processEvents() self.show_result(self.last_result) # plt.rcParams["savefig.dpi"] = 120.0 if "*.gif" in format_str: if not ImageMagickWriter.isAvailable(): self.normal_msg.setWindowTitle(self.tr("Error")) self.normal_msg.setText(self.tr("ImageMagick is not installed, please download and install it from its offical website (https://imagemagick.org/index.php).")) self.normal_msg.exec_() else: self.animation.save(filename, writer="imagemagick", fps=30, progress_callback=save_callback) elif "*.mp4" in format_str: if not FFMpegWriter.isAvailable(): self.normal_msg.setWindowTitle(self.tr("Error")) self.normal_msg.setText(self.tr("FFMpeg is not installed, please download and install it from its offical website (https://ffmpeg.org/).")) self.normal_msg.exec_() else: self.animation.save(filename, writer="ffmpeg", fps=30, progress_callback=save_callback) # plt.rcParams["savefig.dpi"] = 300.0 if not canceled: progress.setValue(100)
def run(self): steps = len(self.recipe.get('actions', [])) * 2 print("{} steps in recipe".format(steps)) executor = FuturaRecipeExecutor(self) def run_thread(): QApplication.processEvents() for i in executor.recipe_generator(): print (i['message']) yield i signals.update_recipe.emit() signals.show_recipe_actions.emit() signals.reset_status_message.emit() self.thread = GeneratorThread(run_thread, steps) print('starting thread') signals.change_status_message.emit('Loading Recipe Data...') progress = QProgressDialog('Loading Recipe Data...', None, 0, steps, findMainWindow().centralWidget()) progress.setWindowModality(Qt.WindowModal) progress.setWindowTitle('Loading...') progress.show() signals.thread_progress.connect(progress.setValue) signals.thread_progress.emit(1) self.thread.start() print('thread started...')
def act(self): if not self.project: logging.fatal("Entered loading without locating a project.") sys.exit(1) logging.info("Entered Loading state.") self.progress_dialog = QProgressDialog("Loading modules...", "Quit", 0, 0) self.progress_dialog.setWindowTitle("Paragon - Loading") self.progress_dialog.setWindowIcon(QIcon("paragon.ico")) self.progress_dialog.setAutoClose(False) self.progress_dialog.hide() self.progress_dialog.show() self.loading_thread = LoadingWorker(self.project) self.loading_thread.over.connect(self._on_loading_success) self.loading_thread.failed.connect(self._on_loading_failure) self.loading_thread.start()
def convert_files(self): self.centroids = None # IF user quits conversion before any waveforms are generated self.settings = self.view.get_settings() if self.settings == None: # IF filedialog is cancelled then stop! return self.model = Model(**self.settings, parent=self) self.model.finished.connect(self.update_settings) self.model.start() self.progress = QProgressDialog("Creating files", "Cancel", 0, 100, self.view, Qt.WindowStaysOnTopHint) self.progress.canceled.connect(self.canceled) self.progress.setFixedWidth( self.progress.width() + 20) #Margin and fixed to avoid annoying jumping self.progress.show()
def exportSelection(self): (filename, ftype) = QFileDialog.getSaveFileName( self, "Choose ply file", dir=self.lastProjectDirectory, filter="Meshes (*.ply)", options=QFileDialog.DontResolveSymlinks | QFileDialog.HideNameFilterDetails) if filename: if not filename.endswith('.ply'): filename += '.ply' progress = QProgressDialog('', None, 0, 100, self) try: self.project.exportply(filename, progress) except BaseException as e: progress.close() raise e
def download(self): ''' Download the youtube URL to the output directory. ''' if (self.check_url_is_valid(self.url) == False or self.check_url_is_valid(self.output) == False): self.show_error_dialog('Invalid input') return try: self.yt = StreamLoader(self.url) except: self.show_error_dialog('Invalid URL') return download_list = self.yt.yt.streams.filter(resolution=self.resolution, only_audio=self.audio_only) if (len(download_list) == 0): self.show_error_dialog('There is not any valid file with the ' 'selected filter. Please updated it!') return download_dialog = DownloadList(download_list) download_dialog.exec_() item_for_download = download_dialog.currentItem if (download_dialog.download_pressed == False): return self.yt.set_resolution(self.resolution) self.yt.set_audio_only(self.audio_only) self.yt.set_output(self.output) self.yt.set_item_for_download(item_for_download) self.download_thread = QThread() self.progress_dialog = QProgressDialog() self.progress_dialog.setWindowTitle('Downloading') self.progress_dialog.setCancelButton(None) self.yt.moveToThread(self.download_thread) self.download_thread.started.connect(self.yt.start_thread) self.yt.finished.connect(self.download_thread.quit) self.yt.yt.register_on_progress_callback(self.yt.show_progress_bar) self.yt.total_bytes.connect(self.progress_dialog.setMaximum) self.yt.bytes_remaining.connect(self.progress_dialog.setValue) self.progress_dialog.show() self.download_thread.start()
def downloadChapters(self, chapters): chp = self.info['chapters'] # Get indexes from Info dictionary idx = [ i for i in range(len(chp)) for volume, name in chapters if name == chp[i]['name'] and volume == chp[i]['volume'] ] # Create Progress Dialog progress = QProgressDialog('Downloading Chapters', 'Cancel', 0, len(idx)) # Show Dialog progress.show() self.app.processEvents() # Dump chapters for i in range(len(idx)): if progress.wasCanceled(): return False Utils.dumpChapterText(self.info, idx[i], self.settings) progress.setValue(i) self.app.processEvents() # Return status return True
def importMVEScene(self): (filename, ftype) = QFileDialog.getOpenFileName( self, "Choose MVE scene", dir=self.lastImportDirectory, filter="MVE Scene (synth_0.out)", options=QFileDialog.DontResolveSymlinks) if filename: directory = str(Path(filename).parent) self.lastImportDirectory = directory progress = QProgressDialog('', None, 0, 100, self) try: self.project.importmve(directory, progress) self.view.update() self.saveSettings() except BaseException as e: progress.close() raise e
def __init__(self, parent, title, **kwargs): super().__init__(total=0, desc=title, **kwargs, gui=True) self.sp = None self.dialog = QProgressDialog(parent) self.dialog.setModal(True) self.dialog.setMinimumDuration(500) self.dialog.setWindowTitle(self.desc) self.dialog.setAutoClose(False) self.dialog.setWindowModality(Qt.WindowModal) self.dialog.setWindowFlag(Qt.WindowCloseButtonHint, False) self.dialog.setWindowFlag(Qt.WindowContextHelpButtonHint, False) label = QLabel() label.setTextFormat(Qt.PlainText) label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter) self.dialog.setLabel(label) self._cancel_event = Event() self._internal_cancel_event = Event() self.dialog.canceled.connect(self.user_cancel)
def uploadToHyperthought(self): auth_control = htauthcontroller.HTAuthorizationController( self.accessKey) metadataJson = ht_utilities.dict_to_ht_metadata( self.usefilterModel.displayed) progress = QProgressDialog("Uploading files...", "Abort Upload", 0, len(self.uselistmodel.metadataList), self) progress.setWindowFlags(Qt.Window | Qt.CustomizeWindowHint | Qt.WindowTitleHint) progress.setAttribute(Qt.WA_DeleteOnClose) self.createUpload.emit(self.uselistmodel.metadataList, auth_control, self.folderuuid, metadataJson) self.uploader.currentUploadDone.connect(progress.setValue) self.uploader.currentlyUploading.connect(progress.setLabelText) self.uploader.allUploadsDone.connect(progress.accept) progress.canceled.connect(lambda: self.uploader.interruptUpload()) progress.setFixedSize(500, 100) progress.exec()
def _update_database(self, area): if area > FROZEN_AREA_OSM_ID_OFFSET or not has_api_connectivity(): self._on_map_ready() return try: retriever = SemanticChangeRetriever() self._pending_count = retriever.new_change_count_in(area) except ConnectionError: QMessageBox.warning( self, _("Warning"), _("Could not retrieve changes in the selected area, using the potentially stale local copy." )) self._on_map_ready() return except UnknownQueueError: QMessageBox.warning( self, _("Warning"), _("The changes queue for the selected database no longer exists on the server, downloading it as if it was a new area." )) self._download_database(area) return if not self._pending_count: self._on_map_ready() return generate_changelog = config().changelogs.enabled if self._pending_count > 10000 and generate_changelog: resp = QMessageBox.question( self, _("Question"), _("The server reports %s pending changes. Do you really want to generate the changelog from all of them? It might take a while." ) % self._pending_count) if resp == QMessageBox.StandardButton.Yes: generate_changelog = False self._progress = QProgressDialog( _("Applying changes for the selected database."), None, 0, self._pending_count, self) self._progress.setWindowTitle(_("Change application")) self._applier = ChangesApplier(area, retriever, generate_changelog) self._applier.will_process_change.connect(self._on_will_process_change) self._applier.changes_applied.connect(self._on_changes_applied) self._applier.redownload_requested.connect( self._on_redownload_requested) self._applier.start()
def start_collecting_measurements(self, interaction): if self.sensor_not_responding: print("DEBUG: warning! Can't start calibration, the sensor is not responding! (in 'RootsApp.start_collecting_measurements()')") error_msg = QMessageBox() error_msg.setText("Can't start calibration!") error_msg.setIcon(QMessageBox.Critical) error_msg.setInformativeText('The sensor is not responding, make sure it is connected') error_msg.setWindowTitle("Error") error_msg.exec_() else: print("starting to collect measurements into the database at location ID {0} (in 'RootsApp.start_collecting_measurements()')".format(interaction.ID)); self.is_training_on = True self.interaction_under_training = interaction database.delete_measurements_from_location(self.database_connection, interaction.ID) # resets the location measurements self.progress_dialog = QProgressDialog("Calibrating", "Abort", 0, self.n_measurements_to_collect, self) self.progress_dialog.setWindowModality(Qt.WindowModal) self.progress_dialog.setWindowTitle("Calibration") self.progress_dialog.setFixedSize(400, 200) self.progress_dialog.setValue(0) self.progress_dialog.exec_()
def run_testing(self): if not self.file_names: self.selected_files.setText( "No files were selected. Go to menu and " "select files to test.") return # Create new queues every run self.queues = [ multiprocessing.Queue(maxsize=self.PROCESS_NUMBER), multiprocessing.Queue(maxsize=self.PROCESS_NUMBER) ] self.STOP_THREADS = False progress = QProgressDialog("Starting Docker and VMs", "Abort start", 0, len(self.file_names) * 2, self) progress.canceled.connect(self.cancel) progress.setWindowModality(Qt.WindowModal) # Create Qthread to show progress self.thread = QThread() self.worker = Worker(self, self.file_names, self.queues) self.worker.moveToThread(self.thread) # Custom signals connected to own functions for progress dialog self.show_steps_thread = threading.Thread(target=self.show_steps, args=(progress, )) self.show_steps_thread.start() # Thread start and stop signals connected with slots self.thread.started.connect(self.worker.run) self.thread.finished.connect(self.remove_processes) # Start thread and force to show progress dialog self.thread.start() progress.forceShow()
def __init__(self, soundfile, parent): self.soundfile = soundfile self.isplaying = False self.time = 0 # current audio position in frames self.audio = QMediaPlayer() self.decoder = QAudioDecoder() self.is_loaded = False self.volume = 100 self.isplaying = False self.decoded_audio = {} self.only_samples = [] self.decoding_is_finished = False self.max_bits = 32768 self.signed = False # File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works self.audio.durationChanged.connect(self.on_durationChanged) self.decoder.finished.connect(self.decode_finished_signal) self.audio.setMedia(QUrl.fromLocalFile(soundfile)) self.decoder.setSourceFilename( soundfile) # strangely inconsistent file-handling progress = QProgressDialog("Loading Audio", "Cancel", 0, 0) progress.setWindowTitle("Progress") progress.setModal(True) progress.forceShow() # It will hang here forever if we don't process the events. while not self.is_loaded: QCoreApplication.processEvents() time.sleep(0.1) self.decode_audio() self.np_data = np.array(self.only_samples) if not self.signed: # don't ask me why this fixes 8 bit samples... self.np_data = self.np_data - self.max_bits / 2 print(len(self.only_samples)) print(self.max_bits) progress.close() self.isvalid = True