def run(self): mutex = QMutex() mutex.lock() try: if self.method == 'post': response = self.session.post(self.url, data=self.data, files=self.files) elif self.method == 'get': response = self.session.get(self.url) elif self.method == 'delete': response = self.session.delete(self.url) else: raise Exception('不正确的方法') if response.status_code >= 300: try: data = response.json() if 'non_field_errors' in data: error_message = data['non_field_errors'] else: error_message = data.get('error', '未知错误') message = '网络请求错误,错误码为{},原因为{}'.format(response.status_code, error_message) self.failed.emit(message) except: print(response.text) else: data = response.json() self.success.emit(data) except requests.Timeout as error: self.failed.emit('网络请求错误,超时,请检查网络连接') except BaseException as error: print('BaseException'.format(error)) self.failed.emit(str(error.args)) finally: mutex.unlock() self.deleteLater()
def __init__(self, interval, project, vcs, parent=None): """ Constructor @param interval new interval in seconds (integer) @param project reference to the project object (Project) @param vcs reference to the version control object @param parent reference to the parent object (QObject) """ super(VcsStatusMonitorThread, self).__init__(parent) self.setObjectName("VcsStatusMonitorThread") self.setTerminationEnabled(True) self.projectDir = project.getProjectPath() self.project = project self.vcs = vcs self.interval = interval self.autoUpdate = False self.statusList = [] self.reportedStates = {} self.shouldUpdate = False self.monitorMutex = QMutex() self.monitorCondition = QWaitCondition() self.__stopIt = False
class Evaluate(QThread): """Thread used to insolate calculation process in entities (stream, project and equipment, so gui can response while calculation is in process""" def __init__(self, parent=None): super(Evaluate, self).__init__(parent) self.mutex = QMutex() def start(self, entity, kwargs): self.entity = entity self.kwargs = kwargs QThread.start(self) def run(self): self.mutex.lock() self.entity(**self.kwargs) self.mutex.unlock()
def __init__(self, weboob, parent=None): QObject.__init__(self, parent) self.weboob = weboob self.weboob.callbacks['login'] = self.callback(self.LoginRequest) self.mutex = QMutex() self.requests = [] self.new_request.connect(self.do_request)
def __init__(self, weboob, parent=None): super(QCallbacksManager, self).__init__(parent) self.weboob = weboob self.weboob.requests.register('login', self.callback(self.LoginRequest)) self.mutex = QMutex() self.requests = [] self.new_request.connect(self.do_request)
def __init__(self, parent=None): super(FortuneThread, self).__init__(parent) self.quit = False self.hostName = '' self.cond = QWaitCondition() self.mutex = QMutex() self.port = 0
def __init__(self, parent=None): super(FetchPage, self).__init__(parent) print('thread initialized') self.mutex = QMutex() self.condition = QWaitCondition() self.restart = False self.abort = False
def __init__(self, plugin_id, address, socket): QThread.__init__(self) self.plugin_id = plugin_id self.address = address self.udp_socket = socket self.finished.connect(self.quit) self.wait = QWaitCondition() self.mutex = QMutex()
def __init__(self, parent=None): super(SyncAllThread, self).__init__(parent) print("thread initialized") self.mutex = QMutex() self.condition = QWaitCondition() self.restart = False self.abort = False
def __init__(self, socket): super(PugdebugServerConnection, self).__init__() self.socket = socket self.mutex = QMutex() self.parser = PugdebugMessageParser()
class Console(QObject): """ The stream-like-object to redirect stream to Qt editor document """ update = pyqtSignal(str) # something is writen to console def __init__(self, editor, color=None, parent=None, waitCond=None): """ :param editor: QTextBrowser or QPlainTextEditor etc. :param color: text color :return: """ super(Console, self).__init__(parent) self.editor = editor self.color = color if self.color: self.editor.setTextColor(self.color) self.mutex = QMutex() self.waitCond = waitCond self.input = None def write(self, content): """ Append to editor's document :param content: :return: """ self.update.emit(content) def read(self): self.editor.setReadOnly(False) self.mutex.lock() self.waitCond.wait(self.mutex) self.mutex.unlock() return self.input def close(self): pass @pyqtSlot(str) def receivedInput(self, content): self.input = content
def __init__(self): super().__init__() self.queue = Queue() self.mutex = QMutex() self.enqueue_signal.connect(self.queue.put) self.done_signal.connect(self.mutex.unlock) self.start()
class QCallbacksManager(QObject): class Request(object): def __init__(self): self.event = Event() self.answer = None def __call__(self): raise NotImplementedError() class LoginRequest(Request): def __init__(self, backend_name, value): super(QCallbacksManager.LoginRequest, self).__init__() self.backend_name = backend_name self.value = value def __call__(self): password, ok = QInputDialog.getText(None, '%s request' % self.value.label, 'Please enter %s for %s' % (self.value.label, self.backend_name), QLineEdit.Password) return password new_request = Signal() def __init__(self, weboob, parent=None): super(QCallbacksManager, self).__init__(parent) self.weboob = weboob self.weboob.requests.register('login', self.callback(self.LoginRequest)) self.mutex = QMutex() self.requests = [] self.new_request.connect(self.do_request) def callback(self, klass): def cb(*args, **kwargs): return self.add_request(klass(*args, **kwargs)) return cb @Slot() def do_request(self): self.mutex.lock() request = self.requests.pop() request.answer = request() request.event.set() self.mutex.unlock() def add_request(self, request): self.mutex.lock() self.requests.append(request) self.mutex.unlock() self.new_request.emit() request.event.wait() return request.answer
def __init__(self, collection): """ Constructor @param collection full pathname of the collection file (string) """ super(HelpDocsInstaller, self).__init__() self.__abort = False self.__collection = collection self.__mutex = QMutex()
class Thread(QThread): """ 단순히 0부터 100까지 카운트만 하는 쓰레드 값이 변경되면 그 값을 change_value 시그널에 값을 emit 한다. """ # 사용자 정의 시그널 선언 change_value = pyqtSignal(int) def __init__(self): QThread.__init__(self) self.cond = QWaitCondition() self.mutex = QMutex() self.cnt = 0 self._status = True def __del__(self): self.wait() def run(self): while True: self.mutex.lock() if not self._status: self.cond.wait(self.mutex) if 100 == self.cnt: self.cnt = 0 self.cnt += 1 self.change_value.emit(self.cnt) self.msleep(100) # ※주의 QThread에서 제공하는 sleep을 사용 self.mutex.unlock() def toggle_status(self): self._status = not self._status if self._status: self.cond.wakeAll() @property def status(self): return self._status
def __init__(self, inTxtWidget, projMan=None, parent=None): ''' Define attributes. Attributes ---------- inTxtWidget: QLineEdit Input line widget of the main window. projMan: Project Object containing information about the project including raw data and some parameters. parent: QObject Parent object. ''' super().__init__(parent) self.itw = inTxtWidget self.projMan = projMan # default analysis parameters self.setBasic(self.loadDefault("basic")) self.toStop = False self.qm = QMutex()
class ReturnValue(Generic[T]): """Pass a return value from a slot back to the signal emitting thread. The ReturnValue has to be send with the signal, the receiving thread than calls .send() to set the value, while the calling thread calls .receive() to wait until the value arrives.""" def __init__(self) -> None: self._mutex = QMutex() self._wait_condition = QWaitCondition() self._value: Optional[T] = None def receive(self) -> T: self._mutex.lock() while self._value is None: self._wait_condition.wait(self._mutex) self._mutex.unlock() return self._value def send(self, value: T) -> None: self._value = value self._wait_condition.wakeAll()
def __init__(self,loop): super(UI,self).__init__() self.sensor_mutex = QMutex()#loop.sensor_mutex self.mirror_mutex = QMutex()#loop.mirror_mutex self.loop = loop try: pass self.loop.finished.connect(self.update) except Exception as e: pass self.draw_boxes = ccfg.show_search_boxes self.draw_lines = ccfg.show_slope_lines self.init_UI() self.frame_timer = FrameTimer('UI',verbose=False) self.update_timer = BlockTimer('UI update method') try: self.profile_update_method = ccfg.profile_ui_update_method except: self.profile_update_method = False self.show()
class FunctionThread(QThread): executed = pyqtSignal(dict) def __init__(self, parent=None): super(FunctionThread, self).__init__(parent) self.mutex = QMutex() self.function = None self.args = None self.kwargs = None self.returnValue = None self.finished.connect(self.on_thread_finished) self.done = True def __del__(self): self.wait() def execute(self, function, *args, **kwargs): locker = QMutexLocker(self.mutex) self.function = function self.args = args self.kwargs = kwargs self.done = False self.start() def run(self): returnValue = self.function(*self.args, **self.kwargs) self.mutex.lock() self.returnValue = returnValue self.mutex.unlock() def on_thread_finished(self): result = {'returnValue': self.returnValue} self.done = True self.executed.emit(result)
class AAThread(QThread): # 시그널 선언 change_value = pyqtSignal(int) def __init__(self, multi=10): QThread.__init__(self) self.cond = QWaitCondition() self.mutex = QMutex() self.count = 0 self._status = True self.multi = multi print(multi) def set_multi(self, multi): self.multi = multi def set_count(self, value): self.count = value def __del__(self): self.wait() def run(self): while True: self.mutex.lock() if not self._status: self.cond.wait(self.mutex) if 100 < self.count: self.count = 0 self.count += 1 self.change_value.emit(self.count) self.msleep(10000 // self.multi) self.mutex.unlock() @property def status(self): return self._status
def __init__(self, sequencelistmodel, parent=None, *args): super().__init__(parent=parent, *args) self.seqlist = sequencelistmodel self._hwsoc = HWSOC() self.mark = 0 self._steps = 0 self._sequence_cache = None # thread locks self.lock_running = QMutex() self.lock_waiting = QMutex() self.lock_waitcond = QWaitCondition() self.lock_steps = QMutex() # state variables self.state_paused = False self.state_running = False self.state_waitinghwok = False self.startTreatment.connect(self._startTreatment) self.stopTreatment.connect(self._stopTreatment) self.restartTreatment.connect(self._restartTreatment) self.abortTreatment.connect(self._abortTreatment) self.setHWOK.connect(self._sethwok) # create QThread and move this object to it self.thread = QThread() self.moveToThread(self.thread) self.thread.start()
def run(self): self.t = 0.0 mutex = QMutex() self.signals.start.emit() self.reset(self.maxT, self.h) while self.t < self.maxT: if self.is_stop: break if self.is_pause: continue mutex.lock() self.model.step(self.h, self.t) mutex.unlock() # pause time self.t += self.h # Emit drawing signal self.signals.draw.emit(self.model) time.sleep(0.01) self.signals.finish.emit()
class Thread(QThread): valueChange = pyqtSignal(int) id_pipLine = pyqtSignal(list) task_finished = pyqtSignal() def __init__(self, results, *args, **kwargs): super(Thread, self).__init__(*args, **kwargs) # results 是从raw_datas查询的所有数据 一般以城市为条件查询 self.results = results self._isPause = True self._value = 1 self.cond = QWaitCondition() self.mutex = QMutex() def next(self): print("下一组数据") self._isPause = False self.cond.wakeAll() self._isPause = True def run(self): while True: self.mutex.lock() if self._isPause: for i in self.results: id = i[0] company_id = i[1] job_id = i[2] item = [id, company_id, job_id] # print(item) self.id_pipLine.emit(item) self.cond.wait(self.mutex) if self._value == len(self.results): self.task_finished.emit() print('第{}组'.format(self._value)) self.valueChange.emit(self._value) self._value += 1 self.mutex.unlock()
def __init__(self, camera, width, height, fps, exposure, gain, brightness, saving_interval, saving_namespace, saving_path): super(CameraWorker, self).__init__() self.grab_flag = False # saving frames to file self.quit_flag = False # flag to kill worker self.change_params_flag = False # flag to change camera settings self.status = True self.frame_number = 0 self.save_roi = False self.roi_origin = (0, 0) self.roi_endpoint = (0, 0) # camera params self.fps = fps self.width = width self.height = height self.exposure = exposure self.gain = gain self.brightness = brightness # grab params self.grab_directory = saving_path self.grab_period = saving_interval self.grab_namespace = saving_namespace self.last_save_time = 0 self.mutex = QMutex() self.raw_image = [] self.back_ground = [] try: self.camera = cv2.VideoCapture(camera, cv2.CAP_DSHOW) self.update_params() ix = 0 while ix < 100: self.camera.read() ix = ix + 1 ret, self.back_ground = self.camera.read() except Exception as ex: print("Cam exp: ", ex) self.backSub = cv2.createBackgroundSubtractorMOG2()
def __init__(self, sharedImageBuffer, deviceUrl, dropFrameIfBufferFull, apiPreference, width, height, setting, parent=None): super(CaptureThread, self).__init__(parent) self.t = QTime() self.doStopMutex = QMutex() self.fps = Queue() # Save passed parameters self.sharedImageBuffer = sharedImageBuffer self.dropFrameIfBufferFull = dropFrameIfBufferFull self.deviceUrl = deviceUrl self._deviceUrl = int(deviceUrl) if deviceUrl.isdigit() else deviceUrl self.localVideo = True if os.path.exists(self._deviceUrl) else False self.apiPreference = apiPreference self.width = width self.height = height # Initialize variables(s) self.captureTime = 0 self.doStop = False self.sampleNumber = 0 self.fpsSum = 0.0 self.statsData = ThreadStatisticsData() self.defaultTime = 0 t = datetime.strptime(setting.skip_duration, '%H:%M:%S') self.skip_duration = timedelta(hours=t.hour, minutes=t.minute, seconds=t.second) self.video_date_time = datetime.strptime( "{} {}".format(setting.video_date, setting.video_time), '%d/%m/%Y %H:%M:%S') self.starting_time = self.video_date_time self.remain_video = None self.pause = False
class WaitingData: def __init__(self): self.logger = logging.getLogger(constants.General.NAME) self.__mutex = QMutex() self.__condition = QWaitCondition() self.__data = None def wait(self): self.__mutex.lock() self.logger.debug(f'Lock: {self}') self.__condition.wait(self.__mutex) def wakeup(self, *args): self.__condition.wakeAll() self.__data = args self.logger.debug(f'Unlock: {self}. Data: {args}') def get_data(self) -> Optional[tuple]: return self.__data
def __init__(self, parent=None): super(FunctionThread, self).__init__(parent) self.mutex = QMutex() self.function = None self.args = None self.kwargs = None self.returnValue = None self.finished.connect(self.on_thread_finished) self.done = True
class Run(QThread): """Run machine learning """ run_signal = pyqtSignal(str) def __init__(self, ml_model, configuration_file): super().__init__() self.ml_model = ml_model self.configuration_file = configuration_file self.run_mut = QMutex() def run(self): """This function is called when data_loading button is clicked. Then, this function will process the data loading. """ self.run_mut.lock() model = self.ml_model(self.configuration_file) model.main_run() self.run_mut.unlock()
def __init__(self, parent=None): """ Constructor @param parent reference to the parent object @type QObject """ super(NetworkUrlInterceptor, self).__init__(parent) self.__interceptors = [] self.__mutex = QMutex() self.__loadSettings()
class Locked(Generic[T]): """Based off https://stackoverflow.com/a/37606669""" def __init__(self, obj: T): super().__init__() self.obj = obj self.lock = QMutex(QMutex.Recursive) def __enter__(self) -> T: self.lock.lock() return self.obj def __exit__(self, *args) -> None: self.lock.unlock() def set(self, value: T) -> T: with self: self.obj = value return value def get(self) -> T: with self: return self.obj
def __init__(self, camera, camera_params: CameraParams): super().__init__() self.camera_params = camera_params self.logger = ErrorLogger(__name__) self.camera_worker_params = CameraWorkerParams self.mutex = QMutex() self.raw_image = [] try: self.camera = cv2.VideoCapture(camera, cv2.CAP_DSHOW) self.update_params() except Exception: self.logger.logger.exception("Error" " during camera parameters" " setting and test image grabbing") msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText("Error") msg.setInformativeText("Failed to init camera.") msg.setWindowTitle("Error") msg.exec_() raise
def __init__(self, sharedImageBuffer, deviceUrl, cameraId, parent=None): super(QThread, self).__init__(parent) self.sharedImageBuffer = sharedImageBuffer self.cameraId = cameraId # Save Device Url self.deviceUrl = deviceUrl # Initialize members self.doStopMutex = QMutex() self.processingMutex = QMutex() self.t = QTime() self.processingTime = 0 self.doStop = False self.enableFrameProcessing = False self.sampleNumber = 0 self.fpsSum = 0.0 self.fps = Queue() self.currentROI = QRect() self.imgProcFlags = ImageProcessingFlags() self.imgProcSettings = ImageProcessingSettings() self.statsData = ThreadStatisticsData() self.frame = None self.currentFrame = None
def __init__(self, uid, pubkey, cache): """ Initializing a person object. :param str uid: The person uid, also known as its uid on the network :param str pubkey: The person pubkey :param cache: The last returned values of the person properties. """ super().__init__() self.uid = uid self.pubkey = pubkey self._cache = cache self._cache_mutex = QMutex()
def setChangeFile(self, changeMsg): """ 接收到平台要求改变文件目录的命令,暂停所有工作;改变工作目录和文件序列;线程重置; 再重启文件选择线程 :param changeMsg: :return: """ if changeMsg: #根据平台发来的信息进行重新初始化 self.timer4audiochoose.stop() self.plainTextEdit.appendPlainText("INFO -- 系统收到新的文件命令,重启运行环境。") mainlog("系统收到新的文件命令,重启运行环境。", "info") self.file_path = changeMsg["file"] self.lineEdit.setText(self.file_path) self.tmpContent["file"] = self.file_path file_num, self.fileDict = countWavFile(self.file_path) self.lineEdit_2.setText("{:}".format(file_num)) if self.work4AudioChoose.isRunning(): try: self.work4AudioChoose.disconnect() self.work4AudioChoose.terminate() if not self.work4AudioChoose.isFinished(): raise Exception("Closed Error") except Exception as e: mainlog("{}:停止音频选择线程错误".format(e), "error") self.plainTextEdit.appendPlainText("ERROR --停止音频选择线程错误") try: self.mutex4audioprocess.unlock() except: pass try: self.mutex4audiochoose = QMutex() except: pass self.work4AudioChoose = WorkThread4AudioChoose( self.file_path, self.thread_num, self.fileDict, self.threadDict, self.mutex4audiochoose) self.work4AudioChoose.trigger.connect(self.procAudio) self.timer4audiochoose.start(5000)
def initToolbar(self): self.toolboxMutex = QMutex() self.toolBarActions = {} self.actionCasks = self.toolBar.addAction( QIcon( "icons/open_icon_library-mac/icons/32x32/categories/applications-other-4.icns" ), "Applications") self.actionCasks.setCheckable(True) self.actionCasks.triggered.connect( lambda a: self.newSelect(a, self.actionCasks, "Casks")) self.toolBarActions["Casks"] = self.actionCasks self.actionLibs = self.toolBar.addAction( QIcon( "icons/open_icon_library-mac/icons/32x32/categories/applications-development-4.icns" ), "Libraries") self.actionLibs.setCheckable(True) self.actionLibs.triggered.connect( lambda a: self.newSelect(a, self.actionLibs, "Libs")) self.toolBarActions["Libs"] = self.actionLibs self.actionUpdates = self.toolBar.addAction( QIcon( "icons/open_icon_library-mac/icons/32x32/actions/update_misc.icns" ), "Updates") self.actionUpdates.setCheckable(True) self.actionUpdates.triggered.connect( lambda a: self.newSelect(a, self.actionUpdates, "Updates")) self.toolBarActions["Updates"] = self.actionUpdates self.actionQueue = self.toolBar.addAction( QIcon( "icons/open_icon_library-mac/icons/32x32/actions/arrow-right-double-3.icns" ), "Queue") self.actionQueue.setCheckable(True) self.actionQueue.triggered.connect( lambda a: self.newSelect(a, self.actionQueue, "Queue")) self.toolBarActions["Queue"] = self.actionQueue
class GetRecListsWorker(QThread): '''获取回收站列表''' folders = pyqtSignal(object) infos = pyqtSignal(object, object) msg = pyqtSignal(str, int) def __init__(self, disk, parent=None): super(GetRecListsWorker, self).__init__(parent) self._disk = disk self._mutex = QMutex() self._is_work = False self._folder_id = None def set_values(self, fid): # 用于获取回收站指定文件夹内文件信息 self._folder_id = fid self.start() def __del__(self): self.wait() def stop(self): self._mutex.lock() self._is_work = False self._mutex.unlock() def run(self): if not self._is_work: self._mutex.lock() self._is_work = True try: if self._folder_id: file_lists = self._disk.get_rec_file_list( folder_id=self._folder_id) self._folder_id = None self.folders.emit(file_lists) raise UserWarning dir_lists = self._disk.get_rec_dir_list() file_lists = self._disk.get_rec_file_list(folder_id=-1) self.infos.emit(dir_lists, file_lists) self.msg.emit("刷新列表成功!", 2000) except TimeoutError: self.msg.emit("网络超时,请稍后重试!", 6000) except UserWarning: pass self._is_work = False self._mutex.unlock() else: self.msg.emit("后台正在运行,请稍后重试!", 3100)
class LoadingBarThread(QThread): change_value = pyqtSignal(int) completed = pyqtSignal() def __init__(self, parent): QThread.__init__(self) self.cond = QWaitCondition() self.mutex = QMutex() self.isRunning = True self.parent = parent def __del__(self): self.wait() def run(self): self.cnt = 0 while True: self.mutex.lock() if not self.isRunning: self.cond.wait(self.mutex) if self.cnt == 50: self.toggle_status() if self.cnt == 100: self.completed.emit() break self.cnt += 1 self.change_value.emit(self.cnt) self.msleep(10) self.mutex.unlock() def toggle_status(self): self.isRunning = not self.isRunning if self.isRunning: self.cond.wakeAll()
class Lock(object): def __init__(self): self._mutex = QMutex() def __enter__(self): self._mutex.lock() def __exit__(self, type, value, tb): self._mutex.unlock() def acquire(self): self._mutex.lock() def release(self): self._mutex.unlock()
class Tcp(QThread): trigger = pyqtSignal() def __init__(self, server, i, tb, parent=None): super(Tcp, self).__init__(parent) self.server = server self.i = i self.tb = tb self.lock = QMutex() # def __del__(self): # self.wait() def run(self): # 处理你要做的业务逻辑,这里是通过一个回调来处理数据,这里的逻辑处理写自己的方法 # wechat.start_auto(self.callback) # self._signal.emit(msg); 可以在这里写信号焕发 # self._signal.emit(msg) ping = Ping.Ping(self.server["add"], int(self.server["port"])) ping.ping(5) time = ping.delay if time == "0.00ms": time = "连接超时" self.lock.lock() try: self.tb.add_row( [self.i, str(self.i + 1) + "-" + self.server["ps"], time]) except: pass finally: self.lock.unlock() self.trigger.emit() def callback(self, msg): # 信号焕发,我是通过我封装类的回调来发起的 # self._signal.emit(msg) pass
def __init__(self, parent=None): super(domeGLWidget, self).__init__(parent) self.xRot = 0 self.yRot = 0 self.zRot = 0 self.z_trans = 300 self.x_trans = 0 self.y_trans = 0 self.z_near = 0.01 self.z_far = 5000. self.frame_id = 0 self.last_frameid = 0 self.g_ambientLight = (0.35, 0.35, 0.35, 1.0) self.g_diffuseLight = (0.75, 0.75, 0.75, 0.7) self.g_specular = (1.0, 1.0, 1.0, 1.0) self.lastPos = QPoint() self.hdCams = [] self.smpl_Lists = [] self.ske_Lists = [] self.smpl = load_model( '/home/xiul/workspace/SMPL_python/smpl/models/basicmodel_m_lbs_10_207_0_v1.0.0.pkl' ) self.smpl_facenum = 0 self.smpl_params = [] self.vts_buffer = [] self.vns_buffer = [] self.inds_buffer = [] self.face_num = [] self.skeletons = [] self.render_lock = QMutex() self.meshlib = meshWrapper( lib_file= '/home/xiul/workspace/PanopticDome/build/libPythonWrapper.so' ) # change this to your built shared library self.meshlib.load_totalmodel()
def __init__(self): super().__init__() self._mutex = QMutex() self._abort = False self._condition = QWaitCondition() self.cur_img = None # load model and default graph # self.classifier = keras.models.load_model('resnet_512.h5') # self.graph = tf.get_default_graph() # REALLY IMPORTANT # setup client self.s = socket.socket() # Create a socket object # host = socket.gethostname() # Get local machine name host = "graphic02.doc.ic.ac.uk" port = 12348 # Reserve a port for your service. self.serverUp = True try: self.s.connect((host, port)) print('SERVER CONNECTED') except Exception as e: print('CANNOT CONNECT TO SERVER: ', e) self.serverUp = False
def __init__(self, portName='', loglevel='WARNING'): QThread.__init__(self) self.logger = Logger(name='ratt.rfid') self.logger.setLogLevelStr(loglevel) self.debug = self.logger.isDebug() self.cond = QWaitCondition() self.mutex = QMutex() self.portName = portName self.waitTimeout = 250 self.quit = False
def __init__(self, data: Dict, selection: Dict, properties: List[PropertyImportData]) -> None: """ :param data: import data parsed from the file to import :param selection: dictionary of selected columns """ super().__init__() self._logger = QGISLogHandler(self.__class__.__name__) self._data: Dict = data self._selection: Dict = selection self._properties: List[PropertyImportData] = properties self._mutex = QMutex() self._cancel = False self._message = ""
def allocReqId(self, req): # TS is good enough uid = str(time.time()) while uid in self.requests: uid = str(time.time()) self.requests[uid] = { 'request': req, 'iodev': QBuffer(parent=req), 'mutex': QMutex() if not self.noMutexes else None } return uid
def __init__(self): super(Ui, self).__init__() # https://github.com/mherrmann/fbs/issues/32 uic.loadUi(appctxt.get_resource('main.ui'), self) # `findChild(,'open')`非必需,比如uic会自动在此自动生成`self.open` self.open_button = self.findChild(QtWidgets.QPushButton, 'open') self.convert_button = self.findChild(QtWidgets.QPushButton, 'convertButton') self.output_button = self.findChild(QtWidgets.QPushButton, 'output') self.output_dir_edit = self.findChild(QtWidgets.QLineEdit, 'output_dir') self.progress_bar = self.findChild(QtWidgets.QProgressBar, 'progressBar') self.list_widget = self.findChild(QtWidgets.QListWidget, 'listWidget') self.open_button.clicked.connect(self.open_button_pressed) self.convert_button.clicked.connect(self.convert_button_pressed) self.output_button.clicked.connect(self.output_button_pressed) self.directory = None self.entries = None self.output_dir = None self.mutex = QMutex() self.thread_pool = QThreadPool() self.thread_pool.setMaxThreadCount(os.cpu_count() - 1) # for not use all system cpu self.show()
def __init__(self, source): super(Tfi, self).__init__() self.lock = QMutex() self.fields = [] self.command_queue = [{ "callback": self._read_feed_vars, "command": "get config.feed", }] self.sendCommand.connect(source.sendCommand) source.packetArrived.connect(self.process_packet, Qt.QueuedConnection) self._send_command()
class SyncEventHandler(QThread): notify_signal = pyqtSignal(object) enqueue_signal = pyqtSignal(object) done_signal = pyqtSignal() def __init__(self): super().__init__() self.queue = Queue() self.mutex = QMutex() self.enqueue_signal.connect(self.queue.put) self.done_signal.connect(self.mutex.unlock) self.start() def done(self): self.done_signal.emit() def run(self): while True: self.mutex.lock() event = self.queue.get() self.notify_signal.emit(event)
class FetchPage(QThread): fetchSignal = pyqtSignal(str, name='fetchComplete') def __init__(self, parent=None): super(FetchPage, self).__init__(parent) print('thread initialized') self.mutex = QMutex() self.condition = QWaitCondition() self.restart = False self.abort = False def __del__(self): self.mutex.lock() self.abort = True self.condition.wakeOne() self.mutex.unlock() self.wait() def fetch(self, page): locker = QMutexLocker(self.mutex) self.page = page if page.content is not None: print('Returning old content') self.fetchSignal.emit(page.content) else: if not self.isRunning(): self.start(QThread.LowPriority) else: self.restart = True self.condition.wakeOne() def run(self): print("running page fetch for " + self.page.title) rest_api = RestAPI() self.page.content = (rest_api.get_page_content(self.page.content_url)) # print(self.page.content) self.fetchSignal.emit(self.page.content) # self.fetchSignal.emit() print('signal emitted') self.mutex.lock() if not self.restart: self.condition.wait(self.mutex) self.restart = False self.mutex.unlock()
def __init__(self, editor, color=None, parent=None, waitCond=None): """ :param editor: QTextBrowser or QPlainTextEditor etc. :param color: text color :return: """ super(Console, self).__init__(parent) self.editor = editor self.color = color if self.color: self.editor.setTextColor(self.color) self.mutex = QMutex() self.waitCond = waitCond self.input = None
def __init__(self, currency, nodes): ''' Constructor of a network :param str currency: The currency name of the community :param list nodes: The root nodes of the network ''' super().__init__() self._root_nodes = nodes self._nodes = [] self._mutex = QMutex() self.currency = currency self.nodes = nodes self._must_crawl = False self._is_perpetual = False self._block_found = self.latest_block
def start_amp_watcher_thread(self): # Set up thread to watch for manual changes of the amp # controls at the amp (rather than gui) so we can update the # gui controls as needed. The way this is done is inspired # by: # http://stackoverflow.com/questions/29243692/pyqt5-how-to-make-qthread-return-data-to-main-thread # https://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/ self.watcher_thread = QThread() self.amp_mutex = QMutex() self.watcher = AmpControlWatcher(self.amp, self.amp_mutex) self.watcher.have_data.connect(self.new_data_from_amp) self.shutdown_threads.connect(self.watcher.stop_watching) self.watcher.moveToThread(self.watcher_thread) self.watcher_thread.started.connect(self.watcher.work) self.watcher_thread.start()
def __init__(self, parent=None): super(RenderThread, self).__init__(parent) self.mutex = QMutex() self.condition = QWaitCondition() self.centerX = 0.0 self.centerY = 0.0 self.scaleFactor = 0.0 self.resultSize = QSize() self.colormap = [] self.restart = False self.abort = False for i in range(RenderThread.ColormapSize): self.colormap.append(self.rgbFromWaveLength(380.0 + (i * 400.0 / RenderThread.ColormapSize)))
class SyncAllThread(QThread): syncCompleteSignal = pyqtSignal(Dbm, name="syncComplete") def __init__(self, parent=None): super(SyncAllThread, self).__init__(parent) print("thread initialized") self.mutex = QMutex() self.condition = QWaitCondition() self.restart = False self.abort = False def __del__(self): self.mutex.lock() self.abort = True self.condition.wakeOne() self.mutex.unlock() self.wait() def sync(self): locker = QMutexLocker(self.mutex) self.dbm = Dbm() print("in sync thread") if not self.isRunning(): self.start(QThread.LowPriority) else: self.restart = True self.condition.wakeOne() def run(self): print("running sync thread") self.dbm.fetch() # print(self.page.content) self.syncCompleteSignal.emit(self.dbm) # self.fetchSignal.emit() print("signal emitted") self.mutex.lock() if not self.restart: self.condition.wait(self.mutex) self.restart = False self.mutex.unlock()
def __init__(self, parent=None): super(Evaluate, self).__init__(parent) self.mutex = QMutex()
def __init__(self): self._mutex = QMutex()
class SwitchRefreshThread(QThread): # Initialize class signals. data_signal = pyqtSignal(bool) """ This function is responsible for initializing any related objects for refresh thread. """ def __init__(self, plugin_id, address, socket): QThread.__init__(self) self.plugin_id = plugin_id self.address = address self.udp_socket = socket self.finished.connect(self.quit) self.wait = QWaitCondition() self.mutex = QMutex() """ This is the entry point for refresh thread. """ def run(self): # Run indefinately. while True: # Wait for trigger. self.mutex.lock() self.wait.wait(self.mutex) self.mutex.unlock() # Receive and discard any datagrams from this socket. self.udp_socket.setblocking(0) try: while True: _ = self.udp_socket.recv(65535) except: pass self.udp_socket.setblocking(1) self.udp_socket.settimeout(WV_REQ_TIMEOUT) try: rx_data = None if DEBUG: print("Sending an update request for", self.plugin_id, "to", self.address) # Send a request update for this plugin. self.udp_socket.sendto(bytes.fromhex(WV_UPDATE) + bytes([((self.plugin_id & 0xFF00) >> 8), (self.plugin_id & 0x00FF)]), self.address) # Receive data form the UDP port. rx_data = self.udp_socket.recv(65535) # If we did receive a vaild reply. if (rx_data[ : 4] == bytes.fromhex(WV_UPDATE_REPLY)): # Remove packet descriptor. rx_data = rx_data[4 : ] # If we did receive some data. if len(rx_data) == 1: if DEBUG: print("Got an update for", self.plugin_id, "from", self.address) # Check if we are now turned on. if (rx_data[0] == WV_PLUGIN_SWITCH_ON): # Signal the data to update the plugin display. self.data_signal.emit(True) # Check if we are now turned off. elif (rx_data[0] == WV_PLUGIN_SWITCH_OFF): # Signal the data to append the plugin display. self.data_signal.emit(False) else: if DEBUG: print("Invalid header for", self.plugin_id, "from", self.address) else: if DEBUG: print("No data received for", self.plugin_id, "from", self.address, "or invalid data was received") else: if DEBUG: print("Invalid header for", self.plugin_id, "from", self.address) except: # Nothing to do here. pass
class Ui(QMainWindow): shutdown_threads = pyqtSignal(name='shutdown_threads') def __init__(self): super(Ui, self).__init__() # Dictionary of methods to call in response to changes to # controls made directly on the amplifier. self.response_funcs = { 'voice': self.voice_changed_on_amp, 'gain': self.gain_changed_on_amp, 'volume': self.volume_changed_on_amp, 'bass': self.bass_changed_on_amp, 'middle': self.middle_changed_on_amp, 'treble': self.treble_changed_on_amp, 'isf': self.isf_changed_on_amp, 'tvp_switch': self.tvp_switch_changed_on_amp, 'tvp_valve': self.tvp_valve_changed_on_amp, 'mod_switch': self.mod_switch_changed_on_amp, 'delay_switch': self.delay_switch_changed_on_amp, 'reverb_switch': self.reverb_switch_changed_on_amp, 'mod_type': self.mod_type_changed_on_amp, 'mod_segval': self.mod_segval_changed_on_amp, 'mod_level': self.mod_level_changed_on_amp, 'mod_speed': self.mod_speed_changed_on_amp, 'mod_manual': self.mod_manual_changed_on_amp, 'delay_type': self.delay_type_changed_on_amp, 'delay_feedback': self.delay_feedback_changed_on_amp, 'delay_level': self.delay_level_changed_on_amp, 'delay_time': self.delay_time_changed_on_amp, 'reverb_type': self.reverb_type_changed_on_amp, 'reverb_size': self.reverb_size_changed_on_amp, 'reverb_level': self.reverb_level_changed_on_amp, 'fx_focus': self.fx_focus_changed_on_amp, 'preset': self.preset_changed_on_amp, 'manual_mode': self.manual_mode_changed_on_amp, 'tuner_mode': self.tuner_mode_changed_on_amp, 'tuner_note': self.tuner_note_changed_on_amp, 'tuner_delta': self.tuner_delta_changed_on_amp, 'resonance': self.resonance_changed_on_amp, 'presence': self.presence_changed_on_amp, 'master_volume': self.master_volume_changed_on_amp, 'preset_name': self.preset_name_from_amp, 'preset_settings': self.preset_settings_from_amp, } uif = os.path.join(os.path.split(__file__)[0], 'outsider.ui') logger.debug('loading GUI file: {0}'.format(uif)) uic.loadUi(uif, self) self.amp_mutex = None self.amp = BlackstarIDAmp() self.watcher_thread = None # For now we don't do anything with preset settings # information other than store them in this list self.preset_settings = [None] * 128 self.controls_enabled(False) self.show() def controls_enabled(self, bool): # Disable/Enable all widgets except the connect button (always enabled) and the master controls (always disabled) if bool is True: widgets = self.findChildren(QGroupBox)#(QObject) for w in widgets: if w == self.masterGroupBox: pass elif w.objectName() == 'TVPGroupBox' and self.amp.model == 'id-core': # self.TVPComboBox.setCurrentText('6L6') # self.TVPRadioButton.setChecked(False) # Don't enable as Core has fixed TVP, probably with type 6L6 pass else: w.setEnabled(bool) elif bool is False: widgets = self.findChildren(QGroupBox)#(QObject) for w in widgets: w.setEnabled(bool) widgets = self.findChildren(QSlider) for w in widgets: w.blockSignals(True) w.setValue(0) w.blockSignals(False) widgets = self.findChildren(QLCDNumber) for w in widgets: w.blockSignals(True) # Not nescessary w.display(0) w.blockSignals(False) # Not nescessary widgets = self.findChildren(QRadioButton) for w in widgets: w.blockSignals(True) w.setChecked(False) w.blockSignals(False) def connect(self): try: self.amp.connect() self.amp.drain() self.start_amp_watcher_thread() self.amp.startup() self.amp.get_all_preset_names() except NotConnectedError: raise def disconnect(self): if self.watcher_thread is not None: logger.debug('Closing down amplifier watching thread') self.shutdown_threads.emit() self.watcher_thread.quit() self.watcher_thread.wait() logger.debug('Amplifier watching thread finished') if self.amp.connected is True: self.amp.disconnect() def start_amp_watcher_thread(self): # Set up thread to watch for manual changes of the amp # controls at the amp (rather than gui) so we can update the # gui controls as needed. The way this is done is inspired # by: # http://stackoverflow.com/questions/29243692/pyqt5-how-to-make-qthread-return-data-to-main-thread # https://mayaposch.wordpress.com/2011/11/01/how-to-really-truly-use-qthreads-the-full-explanation/ self.watcher_thread = QThread() self.amp_mutex = QMutex() self.watcher = AmpControlWatcher(self.amp, self.amp_mutex) self.watcher.have_data.connect(self.new_data_from_amp) self.shutdown_threads.connect(self.watcher.stop_watching) self.watcher.moveToThread(self.watcher_thread) self.watcher_thread.started.connect(self.watcher.work) self.watcher_thread.start() def closeEvent(self, event): # Ran when the application is closed. self.disconnect() super(Ui, self).close() logger.debug('Exiting') @pyqtSlot(dict) def new_data_from_amp(self, settings): for control, value in settings.items(): try: self.response_funcs[control](value) except KeyError: logger.error('Unrecognized control {0}'.format(control)) ###################################################################### # The following methods are called when data is received from the amp ###################################################################### def voice_changed_on_amp(self, value): self.voiceComboBox.blockSignals(True) self.voiceComboBox.setCurrentIndex(value) self.voiceComboBox.blockSignals(False) def gain_changed_on_amp(self, value): self.gainSlider.blockSignals(True) self.gainSlider.setValue(value) self.gainLcdNumber.display(value) self.gainSlider.blockSignals(False) def volume_changed_on_amp(self, value): self.volumeSlider.blockSignals(True) self.volumeSlider.setValue(value) self.volumeLcdNumber.display(value) self.volumeSlider.blockSignals(False) def bass_changed_on_amp(self, value): self.bassSlider.blockSignals(True) self.bassSlider.setValue(value) self.bassLcdNumber.display(value) self.bassSlider.blockSignals(False) def middle_changed_on_amp(self, value): self.middleSlider.blockSignals(True) self.middleSlider.setValue(value) self.middleLcdNumber.display(value) self.middleSlider.blockSignals(False) def treble_changed_on_amp(self, value): self.trebleSlider.blockSignals(True) self.trebleSlider.setValue(value) self.trebleLcdNumber.display(value) self.trebleSlider.blockSignals(False) def isf_changed_on_amp(self, value): self.isfSlider.blockSignals(True) self.isfSlider.setValue(value) self.isfLcdNumber.display(value) self.isfSlider.blockSignals(False) def tvp_switch_changed_on_amp(self, value): value = bool(value) self.TVPRadioButton.blockSignals(True) self.TVPRadioButton.setChecked(value) self.TVPComboBox.setEnabled(value) self.TVPRadioButton.blockSignals(False) def tvp_valve_changed_on_amp(self, value): self.TVPComboBox.blockSignals(True) self.TVPComboBox.setCurrentIndex(value) self.TVPComboBox.blockSignals(False) def mod_switch_changed_on_amp(self, value): value = bool(value) self.modRadioButton.blockSignals(True) self.modRadioButton.setChecked(value) self.modComboBox.setEnabled(value) self.modSegValSlider.setEnabled(value) self.modSegValLabel.setEnabled(value) self.modSegValLcdNumber.setEnabled(value) self.modSpeedSlider.setEnabled(value) self.modSpeedLabel.setEnabled(value) self.modSpeedLcdNumber.setEnabled(value) self.modLevelSlider.setEnabled(value) self.modLevelLabel.setEnabled(value) self.modLevelLcdNumber.setEnabled(value) self.modRadioButton.blockSignals(False) self.assess_manual_enabled() def delay_switch_changed_on_amp(self, value): value = bool(value) self.delayRadioButton.blockSignals(True) self.delayRadioButton.setChecked(value) self.delayComboBox.setEnabled(value) self.delayFeedbackSlider.setEnabled(value) self.delayFeedbackLabel.setEnabled(value) self.delayFeedbackLcdNumber.setEnabled(value) self.delayTimeSlider.setEnabled(value) self.delayTimeLabel.setEnabled(value) self.delayTimeLcdNumber.setEnabled(value) self.delayLevelSlider.setEnabled(value) self.delayLevelLabel.setEnabled(value) self.delayLevelLcdNumber.setEnabled(value) self.delayRadioButton.blockSignals(False) def reverb_switch_changed_on_amp(self, value): value = bool(value) self.reverbRadioButton.blockSignals(True) self.reverbRadioButton.setChecked(value) self.reverbComboBox.setEnabled(value) self.reverbSizeSlider.setEnabled(value) self.reverbSizeLabel.setEnabled(value) self.reverbSizeLcdNumber.setEnabled(value) self.reverbLevelSlider.setEnabled(value) self.reverbLevelLabel.setEnabled(value) self.reverbLevelLcdNumber.setEnabled(value) self.reverbRadioButton.blockSignals(False) def mod_type_changed_on_amp(self, value): self.modComboBox.blockSignals(True) self.modComboBox.setCurrentIndex(value) self.modComboBox.blockSignals(False) self.mod_type_changed(value) def mod_segval_changed_on_amp(self, value): self.modSegValSlider.blockSignals(True) self.modSegValSlider.setValue(value) self.modSegValLcdNumber.display(value) self.modSegValSlider.blockSignals(False) def mod_level_changed_on_amp(self, value): self.modLevelSlider.blockSignals(True) self.modLevelSlider.setValue(value) self.modLevelLcdNumber.display(value) self.modLevelSlider.blockSignals(False) def mod_speed_changed_on_amp(self, value): self.modSpeedSlider.blockSignals(True) self.modSpeedSlider.setValue(value) self.modSpeedLcdNumber.display(value) self.modSpeedSlider.blockSignals(False) def mod_manual_changed_on_amp(self, value): self.modManualSlider.blockSignals(True) self.modManualSlider.setValue(value) self.modManualLcdNumber.display(value) self.modManualSlider.blockSignals(False) def delay_type_changed_on_amp(self, value): self.delayComboBox.blockSignals(True) self.delayComboBox.setCurrentIndex(value) self.delayComboBox.blockSignals(False) def delay_feedback_changed_on_amp(self, value): self.delayFeedbackSlider.blockSignals(True) self.delayFeedbackSlider.setValue(value) self.delayFeedbackLcdNumber.display(value) self.delayFeedbackSlider.blockSignals(False) def delay_level_changed_on_amp(self, value): self.delayLevelSlider.blockSignals(True) self.delayLevelSlider.setValue(value) self.delayLevelLcdNumber.display(value) self.delayLevelSlider.blockSignals(False) def delay_time_changed_on_amp(self, value): self.delayTimeSlider.blockSignals(True) self.delayTimeSlider.setValue(value) self.delayTimeLcdNumber.display(value) self.delayTimeSlider.blockSignals(False) def reverb_type_changed_on_amp(self, value): self.reverbComboBox.blockSignals(True) self.reverbComboBox.setCurrentIndex(value) self.reverbComboBox.blockSignals(False) def reverb_size_changed_on_amp(self, value): self.reverbSizeSlider.blockSignals(True) self.reverbSizeSlider.setValue(value) self.reverbSizeLcdNumber.display(value) self.reverbSizeSlider.blockSignals(False) def reverb_level_changed_on_amp(self, value): self.reverbLevelSlider.blockSignals(True) self.reverbLevelSlider.setValue(value) self.reverbLevelLcdNumber.display(value) self.reverbLevelSlider.blockSignals(False) def fx_focus_changed_on_amp(self, value): # This is a bit of a misnomer, as the amp doesn't emit data if # the user changes the effect focus on the amp. However, when # the user disables an effect in the GUI, if that effect had # focus, we want to move the focus to another effect, if one # is enabled. The way we do that, is in the slots associated # with toggling an effect (see below), if the effect is # disabled we issue a packet to query the state of all # controls, which gives us an opportunity to react in this # function here. if value == 1 and not self.modRadioButton.isChecked(): if self.delayRadioButton.isChecked(): self.amp.set_control('fx_focus', 2) elif self.reverbRadioButton.isChecked(): self.amp.set_control('fx_focus', 3) elif value == 2 and not self.delayRadioButton.isChecked(): if self.reverbRadioButton.isChecked(): self.amp.set_control('fx_focus', 3) elif self.modRadioButton.isChecked(): self.amp.set_control('fx_focus', 1) if value == 3 and not self.reverbRadioButton.isChecked(): if self.modRadioButton.isChecked(): self.amp.set_control('fx_focus', 1) elif self.delayRadioButton.isChecked(): self.amp.set_control('fx_focus', 2) def preset_name_from_amp(self, namelist): idx = namelist[0] - 1 # Presets are numbered from 1 name = str(namelist[0]) + '. ' + namelist[1] item = self.presetNamesList.item(idx) if item is None: self.presetNamesList.insertItem(idx, name) else: item.setText(name) def preset_settings_from_amp(self, settings): self.preset_settings[settings.preset_number] = settings def preset_changed_on_amp(self, value): # TODO: This function is a stub for now, but will need hooking # up to a combo box widget in the gui for selecting/indicating # preset logger.debug('preset changed on amp: {0}'.format(value)) self.presetNamesList.setCurrentRow(value - 1) def manual_mode_changed_on_amp(self, value): # TODO: This also needs hooking up to the preset combo box in # the GUI if value == 1: # Here we'd need to set the combo box to "Manual" pass else: # We're no longer in manual mode, but since in this case # another packet will indicate the preset selected, # there's no need to do anything here. pass logger.debug('manual_mode changed on amp: {0}'.format(value)) def tuner_mode_changed_on_amp(self, value): # TODO: Stub for now - needs hooking into a suitable tuner widget logger.debug('tuner_mode changed on amp: {0}'.format(value)) def tuner_note_changed_on_amp(self, value): # TODO: Stub for now - needs hooking into a suitable tuner widget logger.debug('tuner_note changed on amp: {0}'.format(value)) def tuner_delta_changed_on_amp(self, value): # TODO: Stub for now - needs hooking into a suitable tuner widget logger.debug('tuner_delta changed on amp: {0}'.format(value)) def resonance_changed_on_amp(self, value): self.resonanceSlider.blockSignals(True) self.resonanceSlider.setValue(value) self.resonanceLcdNumber.display(value) self.resonanceSlider.blockSignals(False) logger.debug('resonance changed on amp: {0}'.format(value)) def presence_changed_on_amp(self, value): self.presenceSlider.blockSignals(True) self.presenceSlider.setValue(value) self.presenceLcdNumber.display(value) self.presenceSlider.blockSignals(False) logger.debug('presence changed on amp: {0}'.format(value)) def master_volume_changed_on_amp(self, value): self.masterVolumeSlider.blockSignals(True) self.masterVolumeSlider.setValue(value) self.masterVolumeLcdNumber.display(value) self.masterVolumeSlider.blockSignals(False) logger.debug('master_volume changed on amp: {0}'.format(value)) ################################################################## # The following methods are the slots for changes made on the gui ################################################################## @pyqtSlot() def on_connectToAmpButton_clicked(self): if self.amp.connected is False: try: self.connect() # Enable widgets self.controls_enabled(True) self.connectToAmpButton.setText('Disconnect Amp') except NotConnectedError: QMessageBox.information(self,'Outsider', 'No amplifier found') else: self.disconnect() self.controls_enabled(False) self.connectToAmpButton.setText('Connect to Amp') @pyqtSlot(int) def on_volumeSlider_valueChanged(self, value): logger.debug('Volume slider: {0}'.format(value)) self.amp.set_control('volume', value) @pyqtSlot(int) def on_gainSlider_valueChanged(self, value): logger.debug('Gain slider: {0}'.format(value)) self.amp.set_control('gain', value) @pyqtSlot(int) def on_bassSlider_valueChanged(self, value): logger.debug('Bass slider: {0}'.format(value)) self.amp.set_control('bass', value) @pyqtSlot(int) def on_middleSlider_valueChanged(self, value): logger.debug('Middle slider: {0}'.format(value)) self.amp.set_control('middle', value) @pyqtSlot(int) def on_trebleSlider_valueChanged(self, value): logger.debug('Treble slider: {0}'.format(value)) self.amp.set_control('treble', value) @pyqtSlot(int) def on_isfSlider_valueChanged(self, value): logger.debug('ISF slider: {0}'.format(value)) self.amp.set_control('isf', value) @pyqtSlot(int) def on_TVPComboBox_currentIndexChanged(self, idx): logger.debug('TVP selection: {0}'.format(idx)) self.amp.set_control('tvp_valve', idx) @pyqtSlot(bool) def on_TVPRadioButton_toggled(self, state): logger.debug('TVP switch: {0}'.format(state)) if state == True: self.amp.set_control('tvp_switch', 1) else: self.amp.set_control('tvp_switch', 0) @pyqtSlot(int) def on_voiceComboBox_currentIndexChanged(self, idx): logger.debug('Voice selection: {0}'.format(idx)) self.amp.set_control('voice', idx) @pyqtSlot(bool) def on_modRadioButton_toggled(self, state): logger.debug('Mod switch: {0}'.format(state)) self.amp.set_control('mod_switch', state) if state == 1: self.amp.set_control('fx_focus', 1) else: # Find out if the mod effect had focus before being # deactivated and shift focus to another effect if # possible. The only mechanism we have available to do # this is to get the status of all controls, sadly. self.amp.startup() self.assess_manual_enabled() @pyqtSlot(int) def on_modComboBox_currentIndexChanged(self, value): logger.debug('Mod Combo Box: {0}'.format(value)) self.amp.set_control('mod_type', value) self.amp.set_control('fx_focus', 1) @pyqtSlot(int) def on_modSegValSlider_valueChanged(self, value): logger.debug('Mod SegVal slider: {0}'.format(value)) self.amp.set_control('mod_segval', value) self.amp.set_control('fx_focus', 1) @pyqtSlot(int) def on_modLevelSlider_valueChanged(self, value): logger.debug('Mod Level slider: {0}'.format(value)) self.amp.set_control('mod_level', value) self.amp.set_control('fx_focus', 1) @pyqtSlot(int) def on_modSpeedSlider_valueChanged(self, value): logger.debug('Mod Speed slider: {0}'.format(value)) self.amp.set_control('mod_speed', value) self.amp.set_control('fx_focus', 1) @pyqtSlot(int) def on_modManualSlider_valueChanged(self, value): logger.debug('Mod Manual slider: {0}'.format(value)) self.amp.set_control('mod_manual', value) self.amp.set_control('fx_focus', 1) @pyqtSlot(bool) def on_delayRadioButton_toggled(self, state): logger.debug('Delay switch: {0}'.format(state)) self.amp.set_control('delay_switch', state) if state == 1: self.amp.set_control('fx_focus', 2) else: # Find out if the mod effect had focus before being # deactivated and shift focus to another effect if # possible. The only mechanism we have available to do # this is to get the status of all controls, sadly. self.amp.startup() @pyqtSlot(int) def on_delayComboBox_currentIndexChanged(self, value): logger.debug('Delay Combo Box: {0}'.format(value)) self.amp.set_control('delay_type', value) self.amp.set_control('fx_focus', 2) @pyqtSlot(int) def on_delayFeedbackSlider_valueChanged(self, value): logger.debug('Delay feedback slider: {0}'.format(value)) self.amp.set_control('delay_feedback', value) self.amp.set_control('fx_focus', 2) @pyqtSlot(int) def on_delayLevelSlider_valueChanged(self, value): logger.debug('Delay Level slider: {0}'.format(value)) self.amp.set_control('delay_level', value) self.amp.set_control('fx_focus', 2) @pyqtSlot(int) def on_delayTimeSlider_valueChanged(self, value): logger.debug('Delay Time slider: {0}'.format(value)) self.amp.set_control('delay_time', value) self.amp.set_control('fx_focus', 2) @pyqtSlot(bool) def on_reverbRadioButton_toggled(self, state): logger.debug('Reverb switch: {0}'.format(state)) self.amp.set_control('reverb_switch', state) if state == 1: self.amp.set_control('fx_focus', 3) else: # Find out if the mod effect had focus before being # deactivated and shift focus to another effect if # possible. The only mechanism we have available to do # this is to get the status of all controls, sadly. self.amp.startup() @pyqtSlot(int) def on_reverbComboBox_currentIndexChanged(self, value): logger.debug('Reverb Combo Box: {0}'.format(value)) self.amp.set_control('reverb_type', value) self.amp.set_control('fx_focus', 3) @pyqtSlot(int) def on_reverbSizeSlider_valueChanged(self, value): logger.debug('Reverb Size slider: {0}'.format(value)) self.amp.set_control('reverb_size', value) self.amp.set_control('fx_focus', 3) @pyqtSlot(int) def on_reverbLevelSlider_valueChanged(self, value): logger.debug('Reverb Level slider: {0}'.format(value)) self.amp.set_control('reverb_level', value) self.amp.set_control('fx_focus', 3) @pyqtSlot(QListWidgetItem) def on_presetNamesList_itemDoubleClicked(self, item): idx = self.presetNamesList.currentRow() preset = idx + 1 # Presets are numbered from 1 self.amp.select_preset(preset) @pyqtSlot() def on_renamePresetPushButton_clicked(self): idx = self.presetNamesList.currentRow() preset = idx + 1 # Presets are numbered from 1 name, ok = QInputDialog.getText( self, 'Input Dialog', 'Enter new name for preset {0}:'.format(preset) ) if ok == True: # We need to grab the amp mutex to stop the amp watcher # thread from consuming the packets emitted by the amp in # the preset rename process self.amp_mutex.lock() self.amp.set_preset_name(preset, name) self.amp_mutex.unlock() # When the modulation type is changed, we want to change the label # associated with the segment value control. So, we need to define # a slot to trigger when the modulation type is changed, and a # signal to raise to communicate back to the UI what the label # should be changed to. The signal has argument type str, which is # automatically converted to type QString. mod_segval_label_update = pyqtSignal(str) @pyqtSlot(int) def mod_type_changed(self, value): if value == 0: self.mod_segval_label_update.emit('Mix') elif value == 1: self.mod_segval_label_update.emit('Feedback') elif value == 2: self.mod_segval_label_update.emit('Mix') elif value == 3: self.mod_segval_label_update.emit('FreqMod') self.assess_manual_enabled() @pyqtSlot(int) def on_resonanceSlider_valueChanged(self, value): logger.debug('Resonance slider: {0}'.format(value)) self.amp.set_control('resonance', value) @pyqtSlot(int) def on_presenceSlider_valueChanged(self, value): logger.debug('Presence slider: {0}'.format(value)) self.amp.set_control('presence', value) @pyqtSlot(int) def on_masterVolumeSlider_valueChanged(self, value): logger.debug('Master volume slider: {0}'.format(value)) self.amp.set_control('master_volume', value) # When the modulation is enabled and the modution type is flanger, enable # the manual control. def assess_manual_enabled(self): value = self.modRadioButton.isChecked() and self.modComboBox.currentIndex() == 1 self.modManualSlider.blockSignals(True) self.modManualSlider.setEnabled(value) self.modManualSlider.blockSignals(False)
class RenderThread(QThread): ColormapSize = 512 renderedImage = pyqtSignal(QImage, float) def __init__(self, parent=None): super(RenderThread, self).__init__(parent) self.mutex = QMutex() self.condition = QWaitCondition() self.centerX = 0.0 self.centerY = 0.0 self.scaleFactor = 0.0 self.resultSize = QSize() self.colormap = [] self.restart = False self.abort = False for i in range(RenderThread.ColormapSize): self.colormap.append(self.rgbFromWaveLength(380.0 + (i * 400.0 / RenderThread.ColormapSize))) def __del__(self): self.mutex.lock() self.abort = True self.condition.wakeOne() self.mutex.unlock() self.wait() def render(self, centerX, centerY, scaleFactor, resultSize): locker = QMutexLocker(self.mutex) self.centerX = centerX self.centerY = centerY self.scaleFactor = scaleFactor self.resultSize = resultSize if not self.isRunning(): self.start(QThread.LowPriority) else: self.restart = True self.condition.wakeOne() def run(self): while True: self.mutex.lock() resultSize = self.resultSize scaleFactor = self.scaleFactor centerX = self.centerX centerY = self.centerY self.mutex.unlock() halfWidth = resultSize.width() // 2 halfHeight = resultSize.height() // 2 image = QImage(resultSize, QImage.Format_RGB32) NumPasses = 8 curpass = 0 while curpass < NumPasses: MaxIterations = (1 << (2 * curpass + 6)) + 32 Limit = 4 allBlack = True for y in range(-halfHeight, halfHeight): if self.restart: break if self.abort: return ay = 1j * (centerY + (y * scaleFactor)) for x in range(-halfWidth, halfWidth): c0 = centerX + (x * scaleFactor) + ay c = c0 numIterations = 0 while numIterations < MaxIterations: numIterations += 1 c = c*c + c0 if abs(c) >= Limit: break numIterations += 1 c = c*c + c0 if abs(c) >= Limit: break numIterations += 1 c = c*c + c0 if abs(c) >= Limit: break numIterations += 1 c = c*c + c0 if abs(c) >= Limit: break if numIterations < MaxIterations: image.setPixel(x + halfWidth, y + halfHeight, self.colormap[numIterations % RenderThread.ColormapSize]) allBlack = False else: image.setPixel(x + halfWidth, y + halfHeight, qRgb(0, 0, 0)) if allBlack and curpass == 0: curpass = 4 else: if not self.restart: self.renderedImage.emit(image, scaleFactor) curpass += 1 self.mutex.lock() if not self.restart: self.condition.wait(self.mutex) self.restart = False self.mutex.unlock() def rgbFromWaveLength(self, wave): r = 0.0 g = 0.0 b = 0.0 if wave >= 380.0 and wave <= 440.0: r = -1.0 * (wave - 440.0) / (440.0 - 380.0) b = 1.0 elif wave >= 440.0 and wave <= 490.0: g = (wave - 440.0) / (490.0 - 440.0) b = 1.0 elif wave >= 490.0 and wave <= 510.0: g = 1.0 b = -1.0 * (wave - 510.0) / (510.0 - 490.0) elif wave >= 510.0 and wave <= 580.0: r = (wave - 510.0) / (580.0 - 510.0) g = 1.0 elif wave >= 580.0 and wave <= 645.0: r = 1.0 g = -1.0 * (wave - 645.0) / (645.0 - 580.0) elif wave >= 645.0 and wave <= 780.0: r = 1.0 s = 1.0 if wave > 700.0: s = 0.3 + 0.7 * (780.0 - wave) / (780.0 - 700.0) elif wave < 420.0: s = 0.3 + 0.7 * (wave - 380.0) / (420.0 - 380.0) r = pow(r * s, 0.8) g = pow(g * s, 0.8) b = pow(b * s, 0.8) return qRgb(r*255, g*255, b*255)