def run(self): self.finished.connect(self.onThreadTermination) self.avgUpdateProc = QtCore.QProcess() # self.avgUpdateProc.open(QtCore.QIODevice.Unbuffered) self.avgUpdateProc.destroyed.connect(self.avgProcDestroyed) self.avgUpdateProc.readyRead.connect(self.printOut) self.avgUpdateProc.finished.connect(self.onAVGProcFinish) self.avgUpdateProc.start("gksu", [ "--description=" + langmodule.avgUpdate, "--message=" + langmodule.mustSudo, "avgupdate" ]) try: startLocker = QtCore.QMutexLocker(mutexStartCheck) while not self.avgUpdateProc.waitForStarted(msecs=2000): print(" - avgupdate failed to start - ") #self.avgUpdateProc.readyRead.disconnect() #self.avgUpdateProc.kill() #self.avgUpdateProc.close() self.exitCode = 1 self.avgUpdateProc.finished.emit(self.exitCode) #self.avgUpdateProc.start("gksu", ["avgupdate"]) self.exit() return except Exception as err: print("Failed to initialize Update Process" + str(err)) return self.exec_()
def _keyEvent(self, event_type, key): if not self.active(): return lock = QtCore.QMutexLocker(self.imgMutex) cMods = self.hook.get_current_mods() try: if not "Shift" in cMods and len(key) == 1: key = key.lower() qkey = QtGui.QKeySequence(key)[0] qtype = QtCore.QEvent.KeyPress if event_type == self.hook.KEY_DOWN else QtCore.QEvent.KeyRelease qmod = QtCore.Qt.KeyboardModifiers() for m in cMods: if m == "Shift": qmod = qmod | QtCore.Qt.ShiftModifier if m == "Alt": qmod = qmod | QtCore.Qt.AltModifier if m == "Ctrl": qmod = qmod | QtCore.Qt.ControlModifier e = QtGui.QKeyEvent(qtype, qkey, qmod, key) acdebug("QtKeyEvent for '%s': %d %d %d '%s'", key, e.key(), int(e.modifiers()), qtype, e.text()) if len(key) == 1 or qkey in [QtCore.Qt.Key_Backspace, QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter, QtCore.Qt.Key_Delete, QtCore.Qt.Key_Home, QtCore.Qt.Key_End, QtCore.Qt.Key_Left, QtCore.Qt.Key_Up, QtCore.Qt.Key_Down, QtCore.Qt.Key_Right]: self.app.postEvent(self.page, e) return except: pass acdebug("Ignoring key %s", key)
def _newPage(self, url, ptsInfo): acdebug("qtbrowser: newPage %s", url) lock = QtCore.QMutexLocker(self.imgMutex) if self.hook is None: from ptracker_lib import hooked self.hook = hooked.hook() self.hook.MouseHandler(self._mouseHook) self.hook.RawKeyboardHandler(callback=self._keyEvent, callID=self) self.page = MyWebPage() # connect signals self.page.loadStarted.connect(self.loadStarted) self.page.loadFinished.connect(self.loadFinished) self.page.loadFinished.connect(self.render) self.page.contentsChanged.connect(self.render) self.page.repaintRequested.connect(self.renderRect) self.page.frameCreated.connect(self.render) self.page.scrollRequested.connect(self.render) self.page.mainFrame().javaScriptWindowObjectCleared.connect(functools.partial(self.addJavaScriptObjects, page=self.page, ptsInfo=ptsInfo)) # create a network manager for the page #acdebug("creating network manager") self.ptsManager = ptsInfo.PtsNetworkAccessManager(self.page.networkAccessManager(), ptsInfo.http_server, ptsInfo.ptracker) #acdebug("setting network manager") self.page.setNetworkAccessManager(self.ptsManager) # load the new url #acdebug("load url") self.page.mainFrame().load(url) # post an event that the page gets the focus (for keyboard inputs) self.app.postEvent(self.page, QtGui.QFocusEvent(QtCore.QEvent.FocusIn, QtCore.Qt.MouseFocusReason))
def check(self, mousePos): lock = QtCore.QMutexLocker(self.imgMutex) self.lastCheckTime = time.time() if mousePos != self.lastMousePos: self.lastMousePos = mousePos self.app.postEvent(self.page, QtGui.QMouseEvent(QtCore.QEvent.MouseMove, mousePos, QtCore.Qt.NoButton, QtCore.Qt.NoButton, QtCore.Qt.NoModifier)) return self.cnt
def run(self): self.theOutput = "" result = None #self.avgchkupProc = QtCore.QProcess() self.avgchkupProc = QtCore.QProcess() self.avgchkupProc.started.connect(self.emitProcStarted) self.avgchkupProc.setStandardErrorFile("errfile.txt") self.avgchkupProc.open(QtCore.QIODevice.Unbuffered) self.avgchkupProc.destroyed.connect(self.procDestroyed) self.avgchkupProc.readyRead.connect(self.parseOutput) self.avgchkupProc.finished.connect(self.onAVGprocFinish) self.finished.connect(self.onThreadTermination) #self.avgchkupProc.set try: startLocker = QtCore.QMutexLocker(mutexStartCheck) #print("starting AVGUPDATE process with EUID: " + str(os.geteuid())) #print("Now EUID is: " + str(os.geteuid())) QtGui.QApplication.processEvents() # self.avgchkupProc.start("gksu", ["avgupdate -c"]) self.avgchkupProc.start("gksu", [ "--description=" + langmodule.chkUpdate, "--message=" + langmodule.mustSudo, "avgupdate -c" ]) #print("started UPDATE PROCESS with state: " + str(self.avgchkupProc.state())) if not self.avgchkupProc.waitForStarted(msecs=3000): print("SOS: " + str(self.avgchkupProc.state())) self.sigFailed.emit(True, "") self.exit() return self.exec_() QtGui.QApplication.processEvents() except Exception as err: print("Failed to initialize QProcess: " + str(err)) return
def generate_output(self,input_file, output_file, temp_hdf5): locker = QtCore.QMutexLocker(self.rebin_mutex) shutil.copy(input_file, output_file) output_hdf5 = h5py.File(output_file, 'r+') del output_hdf5["Experiments/__unnamed__/data"] new_ycube = output_hdf5.create_dataset("Experiments/__unnamed__/data", data = temp_hdf5['cube']) output_hdf5.close()
def requestNewFortune(self, hostname, port): locker = QtCore.QMutexLocker(self.mutex) self.hostName = hostname self.port = port if not self.isRunning(): self.start() else: self.cond.wakeOne()
def _clickEvent(self, x,y): if not self.active(): return lock = QtCore.QMutexLocker(self.imgMutex) # emulate a mouse click on a position pos = QtCore.QPoint(x,y) self.app.sendEvent(self.page, QtGui.QMouseEvent(QtCore.QEvent.MouseButtonPress, pos, QtCore.Qt.LeftButton, QtCore.Qt.LeftButton, QtCore.Qt.NoModifier)) self.app.sendEvent(self.page, QtGui.QMouseEvent(QtCore.QEvent.MouseButtonRelease, pos, QtCore.Qt.LeftButton, QtCore.Qt.LeftButton, QtCore.Qt.NoModifier))
def _newSize(self, w, h, zoom): lock = QtCore.QMutexLocker(self.imgMutex) w = round(w*zoom) h = round(h*zoom) acdebug("qtbrowser: setting browser size: %d %d", w, h) self.size = QtCore.QSize(w,h) self.page.mainFrame().setZoomFactor(zoom) self.render()
def consume(self): # when this goes out of scope the lock is opened locker = QtCore.QMutexLocker(QdImageLoader._mutex) if self._index == len(self._paths): return None path = self._paths[self._index] self._index +=1 return path
def read_into_temp_hdf5(self, temp_hdf5, ycube, rows, columns, slices): locker = QtCore.QMutexLocker(self.rebin_mutex) temp_cube = temp_hdf5.create_dataset('cube', (rows, columns, slices)) for input_slice in np.arange(slices): if self.stop_rebin: return image = ycube[:,:,input_slice] rebinned_image = self.rebin(image, rows, columns) temp_cube[:,:,input_slice] = rebinned_image self.update_progress(input_slice) self.progress_window.close()
def load(self, paths): self._stopped = False self.stopLoading() # when this goes out of scope the lock is opened locker = QtCore.QMutexLocker(QdImageLoader._mutex) self._paths = paths self._index = 0 for thread in self._threads: thread.start(QtCore.QThread.IdlePriority)
def stopLoading(self, emitSignal=False): self._stopped = True for thread in self._threads: thread.wait() self._stopped = False # when this goes out of scope the lock is opened locker = QtCore.QMutexLocker(QdImageLoader._mutex) self._paths = [] if emitSignal: self.emit(SIGNAL('loadFinished()'))
def generate_output(self, output_filename, temp_hdf5, global_bool, header, list_xdata, dimension1, dimension2): locker = QtCore.QMutexLocker(self.convert_mutex) output_file = h5py.File(output_filename,'w') data_holder = output_file.create_group("Experiments/__unnamed__") self.build_xdata(data_holder, temp_hdf5, list_xdata) #self.info = self.build_info() self.build_ycube(data_holder, temp_hdf5, global_bool) self.write_header(data_holder, header) self.add_formatting(output_file, data_holder, list_xdata, dimension1, dimension2) output_file.close()
def fit_cube_process(self): locker = QtCore.QMutexLocker(self.spectrum_holder.cube_mutex) self.spectrum_holder.notify_cube_fitting() self.spectrum_viewer.textbox_spectrum_box.setReadOnly(True) (rows,columns,slices) = np.shape(self.data.ycube[...]) #self.progress_bar = self.fit_cube_progress_bar(rows*columns) value = 0 self.stop_fit = False row_count=0 for i in np.arange(rows): column_count = 0 for j in np.arange(columns): peak_holder = DataHolder() ydata = analysis.ydata_calc2(input_ydata=self.data.ycube[i,j,:], input_xdata = self.data.xdata, dtype=self.data.xdata_info['data_type'], display_ev = self.display_ev) ydata = np.float64(ydata) peak_holder.load_from_mf1_cube(self.xdata[:], ydata, j, i) spectrum = peak_holder.get_spectrum(0) if row_count == 0: self.fit_from_spectrum_holder(spectrum) row_count = 1 column_count = 1 elif column_count == 0: index = i*(columns-1) self.fit_from_cube_peaks(spectrum, index) column_count = 1 else: index = -1 self.fit_from_cube_peaks(spectrum, index) peak_list = [] for peak in spectrum.peaks.peak_list: peak_list.append(peak.get_spec()) self.spectrum_holder.cube_peaks.append(peak_list) norm_int_res = self.get_normalized_integrated_residuals(spectrum) self.spectrum_holder.cube_residuals.append(norm_int_res) if self.stop_fit is True: return value += 1 self.update_progress(value) self.progress_window.close() self.spectrum_holder.notify_cube_fitted() self.spectrum_viewer.textbox_spectrum_box.setReadOnly(False) self.spectrum_viewer.label_cube_fitted.setText("Cube Box Loaded")
def render(self, centerX, centerY, scaleFactor, resultSize): locker = QtCore.QMutexLocker(self.mutex) self.centerX = centerX self.centerY = centerY self.scaleFactor = scaleFactor self.resultSize = resultSize if not self.isRunning(): self.start(QtCore.QThread.LowPriority) else: self.restart = True self.condition.wakeOne()
def __del__(self): """ Destructor for the worker thread, makes sure that it exits event loop gracefully by enqueuing a destructor flag """ locker = QtCore.QMutexLocker(self.mutex) # If there are still commands in the queue, clear it if len(self.simQueue) != 0: self.simQueue.clear() self.quit() self.wait()
def convert_progress_bar(self, maximum): """ progress bar window with stop button """ locker = QtCore.QMutexLocker(self.progress_mutex) self.progress_window = QtGui.QWidget() self.progress_window.setWindowTitle("Conversion Progress") progress_bar = QtGui.QProgressBar() button_stop_conversion = QtGui.QPushButton("&Stop Conversion") button_stop_conversion.clicked.connect(self.stop_conversion_now) progress_bar.setMaximum(maximum) box = QtGui.QVBoxLayout() box.addWidget(progress_bar) box.addWidget(button_stop_conversion) self.progress_window.setLayout(box) self.progress_window.show() return progress_bar
def run(self, stuff, hashedPassword, path, binary, arguments, yakuakeTabName): print 'BINARY', binary print 'PATH', path print 'TABNAME', yakuakeTabName print 'ARGS', arguments time.sleep(0.5) with QtCore.QMutexLocker(self.mutex) as locker: if hashedPassword != hashlib.sha224(stuff+self.passwd).hexdigest(): print 'WRONG PASSWORD', hashedPassword return False else: if not yakuakeTabName in self.onTheirWay: self.onTheirWay.append(yakuakeTabName) p = subprocess.Popen(['/opt/robocomp/bin/rcremoteshell', binary, path, yakuakeTabName]+arguments) self.onTheirWay.remove(yakuakeTabName) time.sleep(0.5) return True
def render(self, *args): if not self.active(): return #acdebug("qtbrowser: rendering %d", self.cnt) self.page.setViewportSize(self.size) img = QtGui.QImage(self.size, QtGui.QImage.Format_ARGB32_Premultiplied) img.fill(QtCore.Qt.transparent) palette = QtGui.QApplication.palette() palette.setBrush(QtGui.QPalette.Base, QtCore.Qt.transparent) self.page.setPalette(palette) painter = QtGui.QPainter(img) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setRenderHint(QtGui.QPainter.TextAntialiasing) painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform) self.page.mainFrame().render(painter) painter.end() lock = QtCore.QMutexLocker(self.imgMutex) self.cnt += 1 self.img = img
def read_into_cube(self, fid, temp_hdf5, global_bool, dimension1, dimension2): """read from mf1 file into temporary hdf5 file""" locker = QtCore.QMutexLocker(self.convert_mutex) if global_bool: cube = temp_hdf5.create_dataset('cube', (dimension1, dimension2, 1664)) list_xdata = np.fromfile(file=fid, dtype='>f', count=1600) for i in np.arange(dimension1): for j in np.arange(dimension2): if self.stop_convert: return try: cube[i,j,:] = np.fromfile(file=fid, dtype='>f', count=1664) except: return list_xdata current_spectrum = i*dimension2 + j self.update_progress(current_spectrum) else: cube = temp_hdf5.create_dataset('cube',(dimension1, dimension2, 3264)) for i in np.arange(dimension1): for j in np.arange(dimension2): if self.stop_convert: return try: cube[i,j,:] = np.fromfile(file=fid, dtype='>f', count=3264) except: list_xdata = cube[0,0,0:1600] return current_spectrum = i*dimension2 + j self.update_progress(current_spectrum) list_xdata = cube[0,0,0:1600] return list_xdata
def renderRect(self, dirtyrect): if not self.active(): return # avoid a lock over the whole (sometimes quite long lasting) rendering of the page # we make a copy of the image at the start, unlock everything # and when ready with rednering we can lock ourselfs again lock = QtCore.QMutexLocker(self.imgMutex) img = QtGui.QImage(self.img) lock.unlock() #acdebug("qtbrowser: rendering rect %d / %s", self.cnt, dirtyrect) painter = QtGui.QPainter(img) painter.setRenderHint(QtGui.QPainter.Antialiasing) painter.setRenderHint(QtGui.QPainter.TextAntialiasing) painter.setRenderHint(QtGui.QPainter.SmoothPixmapTransform) painter.setCompositionMode(QtGui.QPainter.CompositionMode_Clear) painter.fillRect(dirtyrect, QtCore.Qt.transparent) painter.setCompositionMode(QtGui.QPainter.CompositionMode_SourceOver) self.page.mainFrame().render(painter, dirtyrect) painter.end() lock.relock() self.cnt += 1 self.img = img
def addCommand(self, command, fileName=None): """ Enqueue a new command to the worker thread queue """ locker = QtCore.QMutexLocker(self.mutex) # Only enqueue a new command if the thread isn't working on an # identical command #if command != self.status: # Enqueue new command self.simQueue.append({'command': command, 'fileName': fileName}) # If the thread has not started yet, start it if not self.keepProcessing and not self.isRunning(): self.keepProcessing = True self.start() self.keepProcessing = True # Wake the worker thread self.commandAdded.wakeOne()
def loadStarted(self): lock = QtCore.QMutexLocker(self.imgMutex) #acdebug("loadStarted") self.loading = time.time()
def loadFinished(self, ok): lock = QtCore.QMutexLocker(self.imgMutex) #acdebug("loadFinished") self.loading = None
def stop_rebin_now(self): self.stop_rebin = True locker = QtCore.QMutexLocker(self.rebin_mutex) self.input_hdf5.close() self.temp_hdf5.close() self.progress_window.close()
def stop(self): with QtCore.QMutexLocker(self.mutex): self.stopped = True
def isStopped(self): with QtCore.QMutexLocker(self.mutex): return self.stopped
def run(self): """ Event loop for worker thread """ self.nextCommand = None self.keepProcessing = True # Enter event loop while True: # Lock the thread resources locker = QtCore.QMutexLocker(self.mutex) # If there are no more commands in the queue, unlock the mutex # and wait for a command to be added if (self.status == 'stopped' and len(self.simQueue) == 0): self.keepProcessing = False self.commandAdded.wait(self.mutex) # Get the next command from the queue self.nextCommand = self.simQueue.popleft() # Update status to reflect next command to be run self.status = self.nextCommand['command'] # Let the GUI know that the next command has started self.getStatus() # If next command comes from the destructor method, break the # run loop, delete the network, and exit if self.status == 'deleting': # Delete the network object and break the loop del self.network break # If a time limit was passed, start the timer only if the next # command is a learning task if self.stopTimer and self.status == 'learning': self.stopTimer.start() # stopped flag acts as a check for the learning algorithm's event # loop; each iteration of the loop is a single learning cycle. For # non-iterative simulator commands, this loop only iterates once if self.keepProcessing: # Run the next command in queue self.network.run(**self.nextCommand) # If the next command finishes before the timer times out, # stop the timer if self.stopTimer and self.stopTimer.isActive(): self.stopTimer.stop() # Unlock the mutex locker.unlock() # Check if all requested commands are completed if len(self.simQueue) == 0: # Special case: let the manager know that the thread is stopped self.status = 'stopped' self.keepProcessing = False self.getStatus() # Reset the simulator status flags self.network.__reset__()
def stop_conversion_now(self): self.stop_convert = True locker = QtCore.QMutexLocker(self.convert_mutex) self.temp_hdf5.close() os.remove(self.output_filename+'temporary') self.progress_window.close()