def _wait_for_clipboard(qtbot, clipboard, mode, expected): timeout = 1000 timer = QElapsedTimer() timer.start() while True: if clipboard.text(mode=mode) == expected: return # We need to poll the clipboard, as for some reason it can change with # emitting changed (?). with qtbot.waitSignal(clipboard.changed, timeout=100, raising=False): pass if timer.hasExpired(timeout): mode_names = { QClipboard.Clipboard: 'clipboard', QClipboard.Selection: 'primary selection', } raise WaitForClipboardTimeout( "Timed out after {timeout}ms waiting for {what}:\n" " expected: {expected!r}\n" " clipboard: {clipboard!r}\n" " primary: {primary!r}.".format( timeout=timeout, what=mode_names[mode], expected=expected, clipboard=clipboard.text(mode=QClipboard.Clipboard), primary=clipboard.text(mode=QClipboard.Selection)) )
def _wait_for_clipboard(qtbot, clipboard, mode, expected): timeout = 1000 timer = QElapsedTimer() timer.start() while True: if clipboard.text(mode=mode) == expected: return # We need to poll the clipboard, as for some reason it can change with # emitting changed (?). with qtbot.waitSignal(clipboard.changed, timeout=100, raising=False): pass if timer.hasExpired(timeout): mode_names = { QClipboard.Clipboard: 'clipboard', QClipboard.Selection: 'primary selection', } raise WaitForClipboardTimeout( "Timed out after {timeout}ms waiting for {what}:\n" " expected: {expected!r}\n" " clipboard: {clipboard!r}\n" " primary: {primary!r}.".format( timeout=timeout, what=mode_names[mode], expected=expected, clipboard=clipboard.text(mode=QClipboard.Clipboard), primary=clipboard.text(mode=QClipboard.Selection)))
def __init__(self, **kwargs): QObject.__init__(self) self.filename = kwargs.get("filename") self.text_code = kwargs.get("code") self.__python_exec = kwargs.get("python_exec") self.pre_script = kwargs.get("pre_script") self.post_script = kwargs.get("post_script") self.__params = kwargs.get("params") self.__elapsed = QElapsedTimer() self.outputw = None self.__current_process = None self.main_process = QProcess(self) self.main_process.started.connect(self._process_started) self.main_process.finished.connect(self._process_finished) self.main_process.finished.connect(self.__post_execution) self.main_process.readyReadStandardOutput.connect(self._refresh_output) self.main_process.readyReadStandardError.connect(self._refresh_error) self.pre_process = QProcess(self) self.pre_process.started.connect(self._process_started) self.pre_process.finished.connect(self._process_finished) self.pre_process.finished.connect(self.__main_execution) self.pre_process.readyReadStandardOutput.connect(self._refresh_output) self.pre_process.readyReadStandardError.connect(self._refresh_error) self.post_process = QProcess(self) self.post_process.started.connect(self._process_started) self.post_process.finished.connect(self._process_finished) self.post_process.readyReadStandardOutput.connect(self._refresh_output) self.post_process.readyReadStandardError.connect(self._refresh_error)
def nextQuestion(self): timer = QElapsedTimer() timer.start() questionWidget = Question(self.mainWindow, self.questionNum + 1, self.result, timer, self.selectedInx) self.mainWindow.widgetList.addWidget(questionWidget) self.mainWindow.widgetList.setCurrentWidget(questionWidget)
def generateSolution(self): """ Generate a solution for the current cubestring and display in the GUI """ self.statusbar.showMessage("Generating Solution") msg = "Generating solution for cubestring: " + self.cube.cubestring self.addLogEntry(msg) timer = QElapsedTimer() timer.start() solution = "No Solution" try: solution = kociemba.solve(self.cube.cubestring) except Exception as err: print(err) error_dialog = QErrorMessage() error_dialog.showMessage(err.args[0]) error_dialog.exec_() solution = err.args[0] self.statusbar.showMessage("Solution generation failed!") msg = "Solution could not be calculated: " + solution self.addLogEntry(msg) self.lineEdit_InOut.setText(solution) self.label_CurrentString.setText("Solution:") self.statusbar.showMessage("Generated Solution") msg = "Solution calculation took: {} ms".format(timer.nsecsElapsed() / 1000000) self.addLogEntry(msg) # self.timer1ms.stop() pass
def __init__(self, parent=None): super().__init__(parent) self._margin_x = 0.0 self._margin_y = 0.0 self._offset_x = 1.0 self._offset_y = 1.0 self._ampl_x = 1.0 self._ampl_y = 1.0 self._coeff_x = 5.0 self._coeff_y = 4.0 self._coeff_delta = 0.0 self._t = 0.0 self._circle_size = 20 self._pen = QPen() self._pen.setWidth(2) self._pen.setColor(Qt.black) self._brush = QBrush(Qt.yellow) self._elapsed_timer = QElapsedTimer() self._timer = QTimer() self._timer.setInterval(1000 / 60) self._timer.timeout.connect(self.update) self.resize(800, 600) self.setWindowTitle('Eyetracker calibration') self._elapsed_timer.start() self._timer.start()
def __init__(self): super().__init__() self.setWindowTitle("KOSAN KEDİ...") self.resize(512, 256) self.sprite_sheet = QImage("sprites-cat-running.png") self.sw = 512 self.sh = 256 self.frame_index = 0 self.x = 0 self.y = 0 self.frames = [] for i in range(2): for j in range(4): self.frames.append(QPoint(j * self.sw, i * self.sh)) print(i, j) self.delta_time = 0 self.animation_time = 0 self.animation_speed = 100 self.timer = QTimer() self.timer.timeout.connect(self.animationLoop) self.elapsedTimer = QElapsedTimer() self.timer.start(50) print("Timer start")
def _wait_for_new(self, timeout, do_skip, **kwargs): """Wait for a log message which doesn't exist yet. Called via wait_for. """ __tracebackhide__ = lambda e: e.errisinstance(WaitForTimeout) message = kwargs.get('message', None) if message is not None: elided = quteutils.elide(repr(message), 100) self._log("\n----> Waiting for {} in the log".format(elided)) spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: # Skip if there are pending messages causing a skip self._maybe_skip() got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): msg = "Timed out after {}ms waiting for {!r}.".format( timeout, kwargs) if do_skip: pytest.skip(msg) else: raise WaitForTimeout(msg) match = self._wait_for_match(spy, kwargs) if match is not None: if message is not None: self._log("----> found it") return match raise quteutils.Unreachable
def _wait_for_new(self, timeout, do_skip, **kwargs): """Wait for a log message which doesn't exist yet. Called via wait_for. """ __tracebackhide__ = lambda e: e.errisinstance(WaitForTimeout) message = kwargs.get('message', None) if message is not None: elided = quteutils.elide(repr(message), 50) self._log("\n----> Waiting for {} in the log".format(elided)) spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: # Skip if there are pending messages causing a skip self._maybe_skip() got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): msg = "Timed out after {}ms waiting for {!r}.".format( timeout, kwargs) if do_skip: pytest.skip(msg) else: raise WaitForTimeout(msg) match = self._wait_for_match(spy, kwargs) if match is not None: if message is not None: self._log("----> found it") return match
def wait_for(self, timeout=None, *, override_waited_for=False, do_skip=False, **kwargs): """Wait until a given value is found in the data. Keyword arguments to this function get interpreted as attributes of the searched data. Every given argument is treated as a pattern which the attribute has to match against. Args: timeout: How long to wait for the message. override_waited_for: If set, gets triggered by previous messages again. do_skip: If set, call pytest.skip on a timeout. Return: The matched line. """ __tracebackhide__ = True if timeout is None: if do_skip: timeout = 2000 elif 'CI' in os.environ: timeout = 15000 else: timeout = 5000 if not kwargs: raise TypeError("No keyword arguments given!") for key in kwargs: assert key in self.KEYS # Search existing messages existing = self._wait_for_existing(override_waited_for, **kwargs) if existing is not None: return existing # If there is none, wait for the message spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: # Skip if there are pending messages causing a skip self._maybe_skip() got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): msg = "Timed out after {}ms waiting for {!r}.".format( timeout, kwargs) if do_skip: pytest.skip(msg) else: raise WaitForTimeout(msg) match = self._wait_for_match(spy, kwargs) if match is not None: return match
def wait_for(self, timeout=None, *, override_waited_for=False, **kwargs): """Wait until a given value is found in the data. Keyword arguments to this function get interpreted as attributes of the searched data. Every given argument is treated as a pattern which the attribute has to match against. Args: timeout: How long to wait for the message. override_waited_for: If set, gets triggered by previous messages again. Return: The matched line. """ __tracebackhide__ = True if timeout is None: if 'CI' in os.environ: timeout = 15000 else: timeout = 5000 if not kwargs: raise TypeError("No keyword arguments given!") for key in kwargs: assert key in self.KEYS # Search existing messages existing = self._wait_for_existing(override_waited_for, **kwargs) if existing is not None: return existing # If there is none, wait for the message spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): raise WaitForTimeout("Timed out after {}ms waiting for " "{!r}.".format(timeout, kwargs)) for args in spy: assert len(args) == 1 line = args[0] matches = [] for key, expected in kwargs.items(): value = getattr(line, key) matches.append(self._match_data(value, expected)) if all(matches): # If we waited for this line, chances are we don't mean the # same thing the next time we use wait_for and it matches # this line again. line.waited_for = True return line
def wait_for(self, timeout=None, **kwargs): """Wait until a given value is found in the data. Keyword arguments to this function get interpreted as attributes of the searched data. Every given argument is treated as a pattern which the attribute has to match against. Return: The matched line. """ if timeout is None: if 'CI' in os.environ: timeout = 15000 else: timeout = 5000 # Search existing messages for line in self._data: matches = [] for key, expected in kwargs.items(): value = getattr(line, key) matches.append(self._match_data(value, expected)) if all(matches) and not line.waited_for: # If we waited for this line, chances are we don't mean the # same thing the next time we use wait_for and it matches # this line again. line.waited_for = True return line # If there is none, wait for the message spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): raise WaitForTimeout("Timed out after {}ms waiting for " "{!r}.".format(timeout, kwargs)) for args in spy: assert len(args) == 1 line = args[0] matches = [] for key, expected in kwargs.items(): value = getattr(line, key) matches.append(self._match_data(value, expected)) if all(matches): # If we waited for this line, chances are we don't mean the # same thing the next time we use wait_for and it matches # this line again. line.waited_for = True return line
def toRate(self): self.updateResult() self.updateTime() timer = QElapsedTimer() timer.start() rateWidget = Rate(self.mainWindow, self.questionNum, self.result, self.selectedInx, timer) self.mainWindow.widgetList.addWidget(rateWidget) self.mainWindow.widgetList.setCurrentWidget(rateWidget)
class Timer(Text): def __init__(self, font_size=100, debug=False): super().__init__(font_size=font_size) self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.setAlignment(Qt.AlignCenter) self.speed = False self.seconds = 0.0 self._elapsed_time = QElapsedTimer() self._timer = QTimer(self, interval=100, timeout=self._update) self._timer.timeout.connect(self._update) self._timer.start() if debug: self.setFrameStyle(QFrame.Box | QFrame.Raised) def set_current_state(self, state): self._current_state = state self.stateChanged.emit(state) def set_speed(self, speed): try: self.speed = float(speed) self._elapsed_time.start() except BaseException: logging.exception("Failed to set timer speed") def set_time(self, time): try: time = time.strip() if time[0] in '+-': self.seconds += float(time) else: self.seconds = float(time) except BaseException: logging.exception("Failed to set timer time") @pyqtSlot() def _update(self): self.seconds += self.speed * self._elapsed_time.elapsed() / 1000 self.seconds = max(self.seconds, 0) self._elapsed_time.start() h, m, s = self.split_time(self.seconds) self.setText(f'{h:02}:{m:02}:{s:02}') @classmethod def split_time(cls, seconds): hours, remaining = divmod(seconds, 3600) minutes, seconds = divmod(remaining, 60) return int(hours), int(minutes), int(seconds)
def initTimer(self): self.gameTimer = QBasicTimer() self.gameTimer.start(TICK_INTERVALL, self) # For deltaTime self.elapsedTimer = QElapsedTimer() self.elapsedTimer.start() self.previous = 0 self.tickCounter = 0
def _searchBatch(self): with self.safeBatch(): start_time = QElapsedTimer() start_time.start() for self.start_line in range(self.start_line, self.editor.lines()): if start_time.hasExpired(10): return self.searchInLine(self.start_line) self.timer.stop() self.finished.emit(0)
def __init__(self): super(DedeNimeur, self).__init__() self.statusBar() self.size, self.height, self.width, self.mines = 30, 10, 10, 10 self.lcd = QLCDNumber() self.lcd.setFixedSize(300, 60) self.board = Board(self.height, self.width, self.mines, self.size) self.timer = QBasicTimer() self.real_timer = QElapsedTimer() vbox = QVBoxLayout() vbox.addWidget(self.lcd) vbox.addWidget(self.board) central = QWidget() central.setLayout(vbox) self.setCentralWidget(central) start = QAction('Start', self) start.setStatusTip('Start') start.setShortcut('Ctrl+N') start.triggered.connect(self.init) exit = QAction('Exit', self) exit.setStatusTip('Exit') exit.setShortcut('Ctrl+Q') exit.triggered.connect(qApp.quit) height = QAction('Height', self) height.setStatusTip('Set board width') height.triggered.connect(self.set_height) width = QAction('Width', self) width.setStatusTip('Set board height') width.triggered.connect(self.set_width) mines = QAction('Mines', self) mines.setStatusTip('Set board mines') mines.triggered.connect(self.set_mines) size = QAction('Size', self) size.setStatusTip('Set button size') size.triggered.connect(self.set_size) toolbar = self.addToolBar('Toolbar') toolbar.addAction(start) toolbar.addAction(width) toolbar.addAction(height) toolbar.addAction(mines) toolbar.addAction(size) toolbar.addAction(exit) self.setWindowTitle(u'DédéNimeur') self.show()
class Bullet: """Bullet contains: 1 StartPosition 2 EndPosition 3 Color 4 Text( A String) 5 Duration It uses the "window" to draw it selft """ #这个叫做 类的属性 Count=0# 通过类名Bullet.bullet访问,就是一个静态变量 Height=GLOBAL.BULLETFONTSIZE+6 #一个Bullet占用的像素高度 def __init__(self, Text, Color,Duration): Bullet.Count+=1 #这个里面self给定的内容则只属于当前对象 self.Text=Text self.Color=Color self.Duration=Duration*1000 #单位是毫秒,输入的是秒 self.IsExpired=False """this method must be called when this bullet is ready to shoot at the first time """ def prepare(self): self.elapsedTimer=QElapsedTimer() self.elapsedTimer.start() #start time self.StartPosition=QPoint(GLOBAL.WINDOWWIDTH+random.randrange(200,500,20),\ (Bullet.Height+(Bullet.Count%(GLOBAL.WINDOWHEIGHT//Bullet.Height))*Bullet.Height)) self.EndPosition=QPoint(-2000 ,self.StartPosition.y()) """Draw this bullet at position x,y ,use painter Returns True indicates this bullet is out of screen """ def draw(self,painter): ratio=self.elapsedTimer.elapsed()/self.Duration if(ratio>0.9): self.IsExpired=True # pos=ratio*self.EndPosition+(1-ratio)*self.StartPosition pos=QPoint(ratio*self.EndPosition.x()+(1-ratio)*self.StartPosition.x(),self.StartPosition.y()) #这里需要插入绘制字体阴影的代码 # # font.setFixedPitch(True) # painter.setFont(font) painter.save() painter.drawText(pos+QPoint(2,2),self.Text) painter.setPen(QPen(self.Color)) painter.drawText(pos,self.Text) painter.restore() # def __del__(self): # Count-=1 # print ("刚刚自动Delete了一个bullet\n")
def __init__(self, project, type_, parent=None): """ Constructor @param project reference to the project object @param type_ project browser type (string) @param parent parent widget of this browser """ QTreeView.__init__(self, parent) self.project = project self._model = project.getModel() self._sortModel = ProjectBrowserSortFilterProxyModel(type_) self._sortModel.setSourceModel(self._model) self.setModel(self._sortModel) self.selectedItemsFilter = [ProjectBrowserFileItem] # contains codes for special menu entries # 1 = specials for Others browser self.specialMenuEntries = [] self.isTranslationsBrowser = False self.expandedNames = [] self.SelectFlags = QItemSelectionModel.SelectionFlags( QItemSelectionModel.Select | QItemSelectionModel.Rows) self.DeselectFlags = QItemSelectionModel.SelectionFlags( QItemSelectionModel.Deselect | QItemSelectionModel.Rows) self._activating = False self.setContextMenuPolicy(Qt.CustomContextMenu) self.customContextMenuRequested.connect(self._contextMenuRequested) self.activated.connect(self._openItem) self._model.rowsInserted.connect(self.__modelRowsInserted) self._connectExpandedCollapsed() self._createPopupMenus() self.currentItemName = None self._init() # perform common initialization tasks self._keyboardSearchString = "" self._keyboardSearchTimer = QElapsedTimer() self._keyboardSearchTimer.invalidate() self._initHookMethods() # perform initialization of the hooks self.hooksMenuEntries = {}
def __init__(self): super().__init__() self.conn_status = False self.query_status = False self.sckt = None self.new_tcp_host = "192.168.43.67" #TCP_HOST_IP self.init_ui() self.q_p1_x = 116.30 self.q_p1_y = 39.97 self.q_p2_x = 116.32 self.q_p2_y = 40.00 self.query_elapsed = None self.proc_elapsed = 0 self.timer = QElapsedTimer()
def _searchBatch(self, needOne=False): with self.safeBatch(): start_time = QElapsedTimer() start_time.start() for self.start_line in range(self.start_line, self.editor.lines()): if not needOne and start_time.hasExpired(10): return matched = self.searchInLine(self.start_line) if matched: needOne = False self.timer.stop() self.finished.emit(0)
def _batchLoad(self): with self.safeBatch(): duration = QElapsedTimer() duration.start() for taginfo in self.parsing: self.db.add_tag(taginfo) if duration.hasExpired(10): return CACHE.addConf(self.parser.path, self.db) self.timer.stop() LOGGER.debug('db %r has finished loading', self.parser.path) self.searchInDb(self.request)
def crawlBatch(self): start_time = QElapsedTimer() start_time.start() prefix_len = len(self.root) + 1 # 1 for the / for path in self.crawler: subpath = path[prefix_len:] qitem = QStandardItem(subpath) qitem.setData(path, AbsolutePathRole) qitem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) self.mdl.appendRow(qitem) if start_time.hasExpired(self.maxSecsPerCrawlBatch * 1000): self.crawlTimer.start(0) break
def __init__(self, parent=None): super().__init__(parent) self._margin_x = 0.0 self._margin_y = 0.0 self._offset_x = 1.0 self._offset_y = 1.0 self._ampl_x = 1.0 self._ampl_y = 1.0 self._coeff_x = 5.0 self._coeff_y = 4.0 self._coeff_delta = 0.0 self._t = 0.0 self._circle_size = 20 self._pen = QPen() self._pen.setWidth(2) self._pen.setColor(Qt.black) self._brush = QBrush(Qt.yellow) self._elapsed_timer = QElapsedTimer() self._timer = QTimer() self._timer.setInterval(1000 / 60) self._timer.timeout.connect(self.update) self.resize(800, 600) self.setWindowTitle("Eyetracker calibration") self._elapsed_timer.start() self._timer.start()
def __init__(self, font_size=100, debug=False): super().__init__(font_size=font_size) self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.setAlignment(Qt.AlignCenter) self.speed = False self.seconds = 0.0 self._elapsed_time = QElapsedTimer() self._timer = QTimer(self, interval=100, timeout=self._update) self._timer.timeout.connect(self._update) self._timer.start() if debug: self.setFrameStyle(QFrame.Box | QFrame.Raised)
def __init__(self, parent): """ Constructor """ super().__init__(parent) self.setupUi(self) self.last_speed = 0.1 self.average_speed = 1 self.timer = QElapsedTimer() self.edit_uid.textChanged.connect(self.values_changed) self.edit_password.textChanged.connect(self.values_changed) self.edit_password_repeat.textChanged.connect(self.values_changed) self.edit_salt.textChanged.connect(self.values_changed) self.edit_pubkey.textChanged.connect(self.values_changed) self.button_generate.clicked.connect(self.action_show_pubkey) self.text_license.setReadOnly(True) self.combo_scrypt_params.currentIndexChanged.connect(self.handle_combo_change) self.scrypt_params = ScryptParams(4096, 16, 1) self.spin_n.setMaximum(2 ** 20) self.spin_n.setValue(self.scrypt_params.N) self.spin_n.valueChanged.connect(self.handle_n_change) self.spin_r.setMaximum(128) self.spin_r.setValue(self.scrypt_params.r) self.spin_r.valueChanged.connect(self.handle_r_change) self.spin_p.setMaximum(128) self.spin_p.setValue(self.scrypt_params.p) self.spin_p.valueChanged.connect(self.handle_p_change) self.label_info.setTextFormat(Qt.RichText)
class Window(QWidget): def __init__(self): super().__init__() self.setWindowTitle("KOSAN KEDİ...") self.resize(512, 256) self.sprite_sheet = QImage("sprites-cat-running.png") self.sw = 512 self.sh = 256 self.frame_index = 0 self.x = 0 self.y = 0 self.frames = [] for i in range(2): for j in range(4): self.frames.append(QPoint(j * self.sw, i * self.sh)) print(i, j) self.delta_time = 0 self.animation_time = 0 self.animation_speed = 100 self.timer = QTimer() self.timer.timeout.connect(self.animationLoop) self.elapsedTimer = QElapsedTimer() self.timer.start(50) print("Timer start") def animationLoop(self): print("Timer started...") self.delta_time = self.elapsedTimer.elapsed() self.elapsedTimer.restart() self.animation_time += self.delta_time if self.animation_time <= self.animation_speed: print("self.animation_time >= self.animation_speed") self.animation_time = 0 self.x = self.frames[self.frame_index].x() self.y = self.frames[self.frame_index].y() self.frame_index += 1 if self.frame_index >= len(self.frames): self.frame_index = 0 print("self.frame_index = 0") self.update() def paintEvent(self, event): qp = QPainter(self) qp.drawImage(0, 0, self.sprite_sheet, self.x, self.y, self.sw, self.sh)
def startProgressBar(self): global PAUSED self.pushStartButton.setEnabled(False) self.pushStopButton.setEnabled(False) for buttonOption in self.button_list: if buttonOption.button != None: buttonOption.button.setEnabled(False) if buttonOption.inputBox != None: buttonOption.inputBox.setEnabled(False) PAUSED = False elapsedTime = QElapsedTimer() elapsedTime.start() self.startApplication()
class Watch(QWidget): required_keys = [] update_interval = 30 def __init__(self): super().__init__() uic.loadUi('src/widgets/default/watch/watch.ui', self) self.timer = QElapsedTimer() self.timer.start() def update_data(self, data): pass def redraw(self): self.lcd.display(format(self.timer.elapsed() / 1000, '.3f')) self.progress.setValue(self.timer.elapsed() % 1000 / 10)
def _wait_for_clipboard(qtbot, clipboard, mode, expected): timeout = 1000 timer = QElapsedTimer() timer.start() while True: if clipboard.text(mode=mode) == expected: return with qtbot.waitSignal(clipboard.changed, timeout=timeout) as blocker: pass if not blocker.signal_triggered or timer.hasExpired(timeout): mode_names = { QClipboard.Clipboard: 'clipboard', QClipboard.Selection: 'primary selection', } raise WaitForTimeout( "Timed out after {}ms waiting for {} in {}.".format( timeout, expected, mode_names[mode]))
def __init__(self): super().__init__() self.targetHostReplyMessage = False self.targetHostReply = False self.proxyisWorking = False self.error = False self.errorCode = False self.errorString = False self.elapsedTime = False self.elapsedTimer = QElapsedTimer()
def __init__(self, parent=None, title=None, *args, **kwargs): super().__init__(parent, *args, **kwargs) self.setWindowTitle(title) # Load Map texture img = Image.open(mapTexture).convert("RGBA") # Create the WebGPU draw function and initialize GPU self.drawFunction = get_draw_function(self, img) self.request_draw(self.mainloop) # Updates on resize / redraw # Set timer to update every frame self.timer = QTimer() self.timer.timeout.connect(self.mainloop) self.timer.start(math.floor(1000 / FPS)) self.timing = QElapsedTimer() self.timing.start() self.oldTime = 0
def startProgressBar(self): global PAUSED self.pushStartButton.setEnabled(False) self.pushStopButton.setEnabled(False) for buttonOption in self.button_list: if buttonOption.button != None: buttonOption.button.setEnabled(False) if buttonOption.inputBox != None: buttonOption.inputBox.setEnabled(False) PAUSED = False elapsedTime = QElapsedTimer() elapsedTime.start() self.startApplication() os.chdir( os.path.join(os.environ.get('HOME'), "teamcode", "appsAway", "scripts")) rc = subprocess.call("./appsAway_setEnvironment.local.sh")
def __init__(self, idRoom): super(RoomRow, self).__init__() self.setStyleSheet( 'QFrame {background: #757575; border-radius: 10px; margin: 0px}') self.setFixedHeight(50) self.callModel = service.CallModel() self.elapsedTimer = QElapsedTimer() self.elapsedTimer.start() self.timerSingle = QTimer() self.timerSingle.setSingleShot(True) self.timerSingle.timeout.connect(self.deactivateBlink) self.timer = QTimer() self.timer.timeout.connect(self.blink) self.stopwatch = QTimer() self.stopwatch.timeout.connect(self.updateStopwatch) self.types = { 'azul': '#0d47a1', 'normal': '#00e676', 'bano': '#fdd835' } self.flagBlink = True self.isActive = False self.callType = None self.room = QLabel(idRoom) self.room.setStyleSheet('font: 25px; color: white') self.room.setAlignment(Qt.AlignCenter) self.timePassed = QLabel('—') self.timePassed.setStyleSheet('color: white') self.timePassed.setFont(QFont('DS-Digital', 25)) self.timePassed.setAlignment(Qt.AlignCenter) hbox = QHBoxLayout(self) hbox.addWidget(self.room) hbox.addWidget(self.timePassed)
class MainWindow(WgpuCanvas): def __init__(self, parent=None, title=None, *args, **kwargs): super().__init__(parent, *args, **kwargs) self.setWindowTitle(title) # Load Map texture img = Image.open(mapTexture).convert("RGBA") # Create the WebGPU draw function and initialize GPU self.drawFunction = get_draw_function(self, img) self.request_draw(self.mainloop) # Updates on resize / redraw # Set timer to update every frame self.timer = QTimer() self.timer.timeout.connect(self.mainloop) self.timer.start(math.floor(1000 / FPS)) self.timing = QElapsedTimer() self.timing.start() self.oldTime = 0 def mainloop(self): """ Main update loop """ if self.is_closed(): self.timer.stop() return # Get current time since launch t = self.timing.elapsed() / 1000 # Call draw fonction with the time self.drawFunction(t) # Display FPS if t - self.oldTime > 0: print(round(1 / (t - self.oldTime), 2), "FPS") self.oldTime = t
def slot_batch_resize(self): dialog = QDialog() dialog.setWindowTitle(i18n("Resize all Pages")) buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) buttons.accepted.connect(dialog.accept) buttons.rejected.connect(dialog.reject) sizesBox = comics_export_dialog.comic_export_resize_widget("Scale", batch=True, fileType=False) exporterSizes = comics_exporter.sizesCalculator() dialog.setLayout(QVBoxLayout()) dialog.layout().addWidget(sizesBox) dialog.layout().addWidget(buttons) if dialog.exec_() == QDialog.Accepted: progress = QProgressDialog(i18n("Resizing pages..."), str(), 0, len(self.setupDictionary["pages"])) progress.setWindowTitle(i18n("Resizing Pages")) progress.setCancelButton(None) timer = QElapsedTimer() timer.start() config = {} config = sizesBox.get_config(config) for p in range(len(self.setupDictionary["pages"])): absoluteUrl = os.path.join(self.projecturl, self.setupDictionary["pages"][p]) progress.setValue(p) timePassed = timer.elapsed() if (p > 0): timeEstimated = (len(self.setupDictionary["pages"]) - p) * (timePassed / p) passedString = str(int(timePassed / 60000)) + ":" + format(int(timePassed / 1000), "02d") + ":" + format(timePassed % 1000, "03d") estimatedString = str(int(timeEstimated / 60000)) + ":" + format(int(timeEstimated / 1000), "02d") + ":" + format(int(timeEstimated % 1000), "03d") progress.setLabelText(str(i18n("{pages} of {pagesTotal} done. \nTime passed: {passedString}:\n Estimated:{estimated}")).format(pages=p, pagesTotal=len(self.setupDictionary["pages"]), passedString=passedString, estimated=estimatedString)) qApp.processEvents() if os.path.exists(absoluteUrl): doc = Application.openDocument(absoluteUrl) listScales = exporterSizes.get_scale_from_resize_config(config["Scale"], [doc.width(), doc.height(), doc.resolution(), doc.resolution()]) doc.scaleImage(listScales[0], listScales[1], listScales[2], listScales[3], "bicubic") doc.waitForDone() doc.save() doc.waitForDone() doc.close()
def __init__(self, parent): super().__init__(parent) self.setFocusPolicy(Qt.StrongFocus) # Init data self._font = QFont('Serif', 14, QFont.Light) self._fpsTimer = QElapsedTimer() self._frameCount = 0 self._fps = 0 self._fpsTimer.start() self._camera = Camera() self._displayFrameRate = False self._cosmeticProperties = None self._environment = None self._cartShape = CartPoleShape() self._axisPlot = AxesPlot(rect=QRectF(-1, 0, 2, 0), axisX=True, axisY=False, pen=QPen(Qt.blue, 0), font=self._font, ticks=11, tickHeight=20) self.setEnabled(False)
class CalibrationWidget(QWidget): cursorPos = pyqtSignal(float, float, "qint64") def __init__(self, parent=None): super().__init__(parent) self._margin_x = 0.0 self._margin_y = 0.0 self._offset_x = 1.0 self._offset_y = 1.0 self._ampl_x = 1.0 self._ampl_y = 1.0 self._coeff_x = 5.0 self._coeff_y = 4.0 self._coeff_delta = 0.0 self._t = 0.0 self._circle_size = 20 self._pen = QPen() self._pen.setWidth(2) self._pen.setColor(Qt.black) self._brush = QBrush(Qt.yellow) self._elapsed_timer = QElapsedTimer() self._timer = QTimer() self._timer.setInterval(1000 / 60) self._timer.timeout.connect(self.update) self.resize(800, 600) self.setWindowTitle("Eyetracker calibration") self._elapsed_timer.start() self._timer.start() def resizeEvent(self, event): w, h = self.width(), self.height() self._margin_x = 0.05 * w self._margin_y = 0.08 * h self._offset_x = 0.5 * w self._offset_y = 0.5 * h self._ampl_x = 0.5 * (w - 2.0 * self._margin_x) self._ampl_y = 0.5 * (h - 2.0 * self._margin_y) self._circle_size = 0.05 * h self._pen.setWidth(0.005 * h) def paintEvent(self, event): qp = QPainter() qp.begin(self) qp.setRenderHint(QPainter.Antialiasing) elapsed = self._elapsed_timer.restart() if elapsed > 100: elapsed = 100 self._t += 0.0002 * elapsed x = self._offset_x + self._ampl_x * math.sin(self._coeff_x * self._t + self._coeff_delta) y = self._offset_y + self._ampl_y * math.sin(self._coeff_y * self._t) qp.setPen(self._pen) qp.setBrush(self._brush) qp.drawEllipse(QPointF(x, y), self._circle_size, self._circle_size) qp.end() self.cursorPos.emit(x, y, QDateTime.currentMSecsSinceEpoch())
class Program(QObject): def __init__(self, **kwargs): QObject.__init__(self) self.filename = kwargs.get("filename") self.text_code = kwargs.get("code") self.__python_exec = kwargs.get("python_exec") self.pre_script = kwargs.get("pre_script") self.post_script = kwargs.get("post_script") self.__params = kwargs.get("params") self.__elapsed = QElapsedTimer() self.outputw = None self.__current_process = None self.main_process = QProcess(self) self.main_process.started.connect(self._process_started) self.main_process.finished.connect(self._process_finished) self.main_process.finished.connect(self.__post_execution) self.main_process.readyReadStandardOutput.connect(self._refresh_output) self.main_process.readyReadStandardError.connect(self._refresh_error) self.pre_process = QProcess(self) self.pre_process.started.connect(self._process_started) self.pre_process.finished.connect(self._process_finished) self.pre_process.finished.connect(self.__main_execution) self.pre_process.readyReadStandardOutput.connect(self._refresh_output) self.pre_process.readyReadStandardError.connect(self._refresh_error) self.post_process = QProcess(self) self.post_process.started.connect(self._process_started) self.post_process.finished.connect(self._process_finished) self.post_process.readyReadStandardOutput.connect(self._refresh_output) self.post_process.readyReadStandardError.connect(self._refresh_error) def start(self): self.__pre_execution() self.outputw.setFocus() def __pre_execution(self): """Execute a script before executing the project""" self.__current_process = self.pre_process file_pre_exec = QFile(self.pre_script) if file_pre_exec.exists(): ext = file_manager.get_file_extension(self.pre_script) args = [] if ext == "py": program = self.python_exec # -u: Force python to unbuffer stding ad stdout args.append("-u") args.append(self.pre_script) elif ext == "sh": program = "bash" args.append(self.pre_script) else: program = self.pre_script self.pre_process.setProgram(program) self.pre_process.setArguments(args) self.pre_process.start() else: self.__main_execution() def __main_execution(self): self.__elapsed.start() self.__current_process = self.main_process if not self.only_text: # In case a text is executed and not a file or project file_directory = file_manager.get_folder(self.filename) self.main_process.setWorkingDirectory(file_directory) self.main_process.setProgram(self.python_exec) self.main_process.setArguments(self.arguments) environment = QProcessEnvironment() system_environment = self.main_process.systemEnvironment() for env in system_environment: key, value = env.split("=", 1) environment.insert(key, value) self.main_process.setProcessEnvironment(environment) self.main_process.start() def __post_execution(self): """Execute a script after executing the project.""" self.__current_process = self.post_process file_pre_exec = QFile(self.post_script) if file_pre_exec.exists(): ext = file_manager.get_file_extension(self.post_script) args = [] if ext == "py": program = self.python_exec # -u: Force python to unbuffer stding ad stdout args.append("-u") args.append(self.post_script) elif ext == "sh": program = "bash" args.append(self.post_script) else: program = self.post_script self.post_process.setProgram(program) self.post_process.setArguments(args) self.post_process.start() @property def process_name(self): proc = self.__current_process return proc.program() + " " + " ".join(proc.arguments()) def update(self, **kwargs): self.text_code = kwargs.get("code") self.__python_exec = kwargs.get("python_exec") self.pre_script = kwargs.get("pre_script") self.post_script = kwargs.get("post_script") self.__params = kwargs.get("params") def set_output_widget(self, ow): self.outputw = ow self.outputw.inputRequested.connect(self._write_input) def _write_input(self, data): self.main_process.write(data.encode()) self.main_process.write(b"\n") def is_running(self): running = False if self.main_process.state() == QProcess.Running: running = True return running def _process_started(self): time_str = QTime.currentTime().toString("hh:mm:ss") text = time_str + " Running: " + self.process_name self.outputw.append_text(text) self.outputw.setReadOnly(False) def _process_finished(self, code, status): frmt = OutputWidget.Format.NORMAL if status == QProcess.NormalExit == code: text = translations.TR_PROCESS_EXITED_NORMALLY % code else: text = translations.TR_PROCESS_INTERRUPTED frmt = OutputWidget.Format.ERROR self.outputw.append_text(text, frmt) if self.__current_process is self.main_process: tformat = QTime(0, 0, 0, 0).addMSecs( self.__elapsed.elapsed() + 500) time = tformat.toString("h:mm:ss") if time.startswith("0:"): # Don't display zero hours time = time[2:] self.outputw.append_text(translations.TR_ELAPSED_TIME.format(time)) self.outputw.setReadOnly(True) def _refresh_output(self): data = self.__current_process.readAllStandardOutput().data().decode() for line in data.splitlines(): self.outputw.append_text( line, text_format=OutputWidget.Format.NORMAL) def _refresh_error(self): data = self.__current_process.readAllStandardError().data().decode() for line_text in data.splitlines(): frmt = OutputWidget.Format.ERROR if self.outputw.patLink.match(line_text): frmt = OutputWidget.Format.ERROR_UNDERLINE self.outputw.append_text(line_text, frmt) def display_name(self): name = "New document" if not self.only_text: name = file_manager.get_basename(self.filename) return name @property def only_text(self): return self.filename is None @property def python_exec(self): py_exec = self.__python_exec if not py_exec: py_exec = settings.PYTHON_EXEC return py_exec @property def arguments(self): args = [] if self.text_code: args.append("-c") args.append(self.text_code) else: # Force python to unbuffer stding and stdout args.append("-u") args += settings.EXECUTION_OPTIONS.split() args.append(self.filename) return args def kill(self): self.main_process.kill()
def prepare(self): self.elapsedTimer=QElapsedTimer() self.elapsedTimer.start() #start time self.StartPosition=QPoint(GLOBAL.WINDOWWIDTH+random.randrange(200,500,20),\ (Bullet.Height+(Bullet.Count%(GLOBAL.WINDOWHEIGHT//Bullet.Height))*Bullet.Height)) self.EndPosition=QPoint(-2000 ,self.StartPosition.y())
class DedeNimeur(QMainWindow): def __init__(self): super(DedeNimeur, self).__init__() self.statusBar() self.size, self.height, self.width, self.mines = 30, 10, 10, 10 self.lcd = QLCDNumber() self.lcd.setFixedSize(300, 60) self.board = Board(self.height, self.width, self.mines, self.size) self.timer = QBasicTimer() self.real_timer = QElapsedTimer() vbox = QVBoxLayout() vbox.addWidget(self.lcd) vbox.addWidget(self.board) central = QWidget() central.setLayout(vbox) self.setCentralWidget(central) start = QAction('Start', self) start.setStatusTip('Start') start.setShortcut('Ctrl+N') start.triggered.connect(self.init) exit = QAction('Exit', self) exit.setStatusTip('Exit') exit.setShortcut('Ctrl+Q') exit.triggered.connect(qApp.quit) height = QAction('Height', self) height.setStatusTip('Set board width') height.triggered.connect(self.set_height) width = QAction('Width', self) width.setStatusTip('Set board height') width.triggered.connect(self.set_width) mines = QAction('Mines', self) mines.setStatusTip('Set board mines') mines.triggered.connect(self.set_mines) size = QAction('Size', self) size.setStatusTip('Set button size') size.triggered.connect(self.set_size) toolbar = self.addToolBar('Toolbar') toolbar.addAction(start) toolbar.addAction(width) toolbar.addAction(height) toolbar.addAction(mines) toolbar.addAction(size) toolbar.addAction(exit) self.setWindowTitle(u'DédéNimeur') self.show() def init(self): if self.mines < self.height * self.width: self.board.height = self.height self.board.width = self.width self.board.mines = self.mines self.board.size = self.size self.board.init() else: QMessageBox.question(self, 'NOPE', u"Va falloir spécifier un truc cohérent…", QMessageBox.Ok) def set_height(self): text, ok = QInputDialog.getText(self, 'Settings', 'height') if ok: self.height = int(text) self.init() def set_width(self): text, ok = QInputDialog.getText(self, 'Settings', 'width') if ok: self.width = int(text) self.init() def set_mines(self): text, ok = QInputDialog.getText(self, 'Settings', 'mines') if ok: self.mines = int(text) self.init() def set_size(self): text, ok = QInputDialog.getText(self, 'Settings', 'size') if ok: self.size = int(text) self.init() def start_timers(self): self.timer.start(100, self) self.real_timer.start() self.lcd.display(int(self.real_timer.elapsed() / 1000)) def stop_timers(self): self.timer.stop() return self.real_timer.elapsed() def timerEvent(self, e): self.lcd.display(int(self.real_timer.elapsed() / 1000))
class ConnectionConfigView(QDialog, Ui_ConnectionConfigurationDialog): """ Connection config view """ values_changed = pyqtSignal() def __init__(self, parent): """ Constructor """ super().__init__(parent) self.setupUi(self) self.last_speed = 0.1 self.average_speed = 1 self.timer = QElapsedTimer() self.edit_uid.textChanged.connect(self.values_changed) self.edit_password.textChanged.connect(self.values_changed) self.edit_password_repeat.textChanged.connect(self.values_changed) self.edit_salt.textChanged.connect(self.values_changed) self.edit_pubkey.textChanged.connect(self.values_changed) self.button_generate.clicked.connect(self.action_show_pubkey) self.text_license.setReadOnly(True) self.combo_scrypt_params.currentIndexChanged.connect(self.handle_combo_change) self.scrypt_params = ScryptParams(4096, 16, 1) self.spin_n.setMaximum(2 ** 20) self.spin_n.setValue(self.scrypt_params.N) self.spin_n.valueChanged.connect(self.handle_n_change) self.spin_r.setMaximum(128) self.spin_r.setValue(self.scrypt_params.r) self.spin_r.valueChanged.connect(self.handle_r_change) self.spin_p.setMaximum(128) self.spin_p.setValue(self.scrypt_params.p) self.spin_p.valueChanged.connect(self.handle_p_change) self.label_info.setTextFormat(Qt.RichText) def handle_combo_change(self, index): strengths = [ (2 ** 12, 16, 1), (2 ** 14, 32, 2), (2 ** 16, 32, 4), (2 ** 18, 64, 8), ] self.spin_n.blockSignals(True) self.spin_r.blockSignals(True) self.spin_p.blockSignals(True) self.spin_n.setValue(strengths[index][0]) self.spin_r.setValue(strengths[index][1]) self.spin_p.setValue(strengths[index][2]) self.spin_n.blockSignals(False) self.spin_r.blockSignals(False) self.spin_p.blockSignals(False) def set_license(self, currency): license_text = self.tr(G1_LICENCE) self.text_license.setText(license_text) def handle_n_change(self, value): spinbox = self.sender() self.scrypt_params.N = ConnectionConfigView.compute_power_of_2(spinbox, value, self.scrypt_params.N) def handle_r_change(self, value): spinbox = self.sender() self.scrypt_params.r = ConnectionConfigView.compute_power_of_2(spinbox, value, self.scrypt_params.r) def handle_p_change(self, value): spinbox = self.sender() self.scrypt_params.p = ConnectionConfigView.compute_power_of_2(spinbox, value, self.scrypt_params.p) @staticmethod def compute_power_of_2(spinbox, value, param): if value > 1: if value > param: value = pow(2, ceil(log(value) / log(2))) else: value -= 1 value = 2 ** int(log(value, 2)) else: value = 1 spinbox.blockSignals(True) spinbox.setValue(value) spinbox.blockSignals(False) return value def display_info(self, info): self.label_info.setText(info) def set_currency(self, currency): self.label_currency.setText(currency) def add_node_parameters(self): server = self.lineedit_add_address.text() port = self.spinbox_add_port.value() return server, port async def show_success(self, notification): if notification: toast.display(self.tr("UID broadcast"), self.tr("Identity broadcasted to the network")) else: await QAsyncMessageBox.information(self, self.tr("UID broadcast"), self.tr("Identity broadcasted to the network")) def show_error(self, notification, error_txt): if notification: toast.display(self.tr("UID broadcast"), error_txt) self.label_info.setText(self.tr("Error") + " " + error_txt) def set_nodes_model(self, model): self.tree_peers.setModel(model) def set_creation_layout(self, currency): """ Hide unecessary buttons and display correct title """ self.setWindowTitle(self.tr("New connection to {0} network").format(ROOT_SERVERS[currency]["display"])) def action_show_pubkey(self): salt = self.edit_salt.text() password = self.edit_password.text() pubkey = SigningKey(salt, password, self.scrypt_params).pubkey self.label_info.setText(pubkey) def account_name(self): return self.edit_account_name.text() def set_communities_list_model(self, model): """ Set communities list model :param sakia.models.communities.CommunitiesListModel model: """ self.list_communities.setModel(model) def stream_log(self, log): """ Add log to :param str log: """ self.plain_text_edit.appendPlainText(log) def progress(self, step_ratio): """ :param float ratio: the ratio of progress of current step (between 0 and 1) :return: """ SMOOTHING_FACTOR = 0.005 if self.timer.elapsed() > 0: value = self.progress_bar.value() next_value = value + 1000000*step_ratio speed_percent_by_ms = (next_value - value) / self.timer.elapsed() self.average_speed = SMOOTHING_FACTOR * self.last_speed + (1 - SMOOTHING_FACTOR) * self.average_speed remaining = (self.progress_bar.maximum() - next_value) / self.average_speed self.last_speed = speed_percent_by_ms displayed_remaining_time = QDateTime.fromTime_t(remaining).toUTC().toString("hh:mm:ss") self.progress_bar.setFormat(self.tr("{0} remaining...".format(displayed_remaining_time))) self.progress_bar.setValue(next_value) self.timer.restart() def set_progress_steps(self, steps): self.progress_bar.setValue(0) self.timer.start() self.progress_bar.setMaximum(steps*1000000) def set_step(self, step): self.progress_bar.setValue(step * 1000000) async def show_register_message(self, blockchain_parameters): """ :param sakia.data.entities.BlockchainParameters blockchain_parameters: :return: """ days, hours, minutes, seconds = timestamp_to_dhms(blockchain_parameters.idty_window) expiration_time_str = self.tr("{days} days, {hours}h and {min}min").format(days=days, hours=hours, min=minutes) dialog = QDialog(self) about_dialog = Ui_CongratulationPopup() about_dialog.setupUi(dialog) dialog.setWindowTitle("Registration") about_dialog.label.setText(self.tr(""" <p><b>Congratulations !</b><br> <br> You just published your identity to the network.<br> For your identity to be registered, you will need<br> <b>{certs} certifications</b> from members.<br> Once you got the required certifications, <br> you will be able to validate your registration<br> by <b>publishing your membership request !</b><br> Please notice that your identity document <br> <b>will expire in {expiration_time_str}.</b><br> If you failed to get {certs} certifications before this time, <br> the process will have to be restarted from scratch.</p> """.format(certs=blockchain_parameters.sig_qty, expiration_time_str=expiration_time_str))) await dialog_async_exec(dialog)