def update_duration(self, current_duration): """Calculate the time played and the length of the song. Both of these times are sent to duration_label() in order to display the times on the toolbar. """ duration = self.duration if current_duration or duration: time_played = QTime((current_duration / 3600) % 60, (current_duration / 60) % 60, (current_duration % 60), (current_duration * 1000) % 1000) song_length = QTime((duration / 3600) % 60, (duration / 60) % 60, (duration % 60), (duration * 1000) % 1000) if duration > 3600: time_format = "hh:mm:ss" else: time_format = "mm:ss" time_display = "{} / {}" .format(time_played.toString(time_format), song_length.toString(time_format)) else: time_display = "" self.duration_label.setText(time_display)
def updateDurationInfo(self, currentInfo): duration = self.duration if currentInfo or duration: currentTime = QTime((currentInfo/3600)%60, (currentInfo/60)%60, currentInfo%60, (currentInfo*1000)%1000) totalTime = QTime((duration/3600)%60, (duration/60)%60, duration%60, (duration*1000)%1000); format = 'hh:mm:ss' if duration > 3600 else 'mm:ss' tStr = currentTime.toString(format) + " / " + totalTime.toString(format) else: tStr = "" self.labelDuration.setText(tStr)
def data(self, index, role=Qt.DisplayRole): if not index.isValid(): return QVariant() if index.row() >= len(self.songs) or index.row() < 0: return QVariant() song = self.songs[index.row()] if role in (Qt.DisplayRole, Qt.ToolTipRole): if index.column() == 0: return self._source_name_map.get(song.source, '').strip() elif index.column() == 1: return song.title elif index.column() == 2: m, s = parse_ms(song.duration) duration = QTime(0, m, s) return duration.toString('mm:ss') elif index.column() == 3: return song.artists_name elif index.column() == 4: return song.album_name elif role == Qt.TextAlignmentRole: if index.column() == 0: return Qt.AlignCenter | Qt.AlignBaseline elif role == Qt.EditRole: return 1 elif role == Qt.UserRole: return song return QVariant()
def addClicked(self, fileNames): """Fill the playlist with fileNames' info.""" if fileNames is None: return self.playlistTable.setSortingEnabled(False) songsToAdd = len(fileNames) for name, row in zip(fileNames, range(songsToAdd)): currentRow = row + self.playlist.mediaCount() - songsToAdd self.playlistTable.insertRow(currentRow) artist = self.playerCore.getArtist(name)[0] title = self.playerCore.getTitle(name)[0] album = self.playerCore.getAlbum(name)[0] seconds = self.playerCore.getDuration(name) duration = QTime(0, seconds // 60, seconds % 60) duration = duration.toString('mm:ss') rowInfo = [artist, title, album, duration] for info, index in zip(rowInfo, range(4)): cell = QTableWidgetItem(info) self.playlistTable.setItem(currentRow, index, cell) font = QFont(info, weight=QFont.Normal) cell.setFont(font) cell.setTextAlignment(Qt.AlignCenter) self.playlistTable.setSortingEnabled(True) for index in range(4): self.playlistTable.resizeColumnToContents(index)
def recalculate(self): longitude = self.left.ui.LongitudeLineEdit.value() # lambda latitude = self.left.ui.latitudeLineEdit.value() # Phi treeHeight = int(self.left.ui.treeHeightLineEdit.value()) # Step 1: calculate sun set and sun rise dateTime = QDateTime(self.left.ui.dateEdit.date(), QTime(12,0), Qt.UTC) self.theSun.recalculate(dateTime, longitude, latitude, treeHeight) sunRise = QTime(int(self.theSun.Aufgang), int(60.0*(self.theSun.Aufgang - int(self.theSun.Aufgang)))) sunSet = QTime(int(self.theSun.Untergang), int(60.0*(self.theSun.Untergang - int(self.theSun.Untergang)))) self.left.ui.sunriseLineEdit.setText(sunRise.toString(Qt.ISODate)) self.left.ui.sunsetLineEdit.setText(sunSet.toString(Qt.ISODate)) minuteStart = sunRise.msecsSinceStartOfDay() / 1000 / 60 minuteEnd = sunSet.msecsSinceStartOfDay() / 1000 / 60 self.left.ui.timeSlider.setMinimum(minuteStart) self.left.ui.timeSlider.setMaximum(minuteEnd) # Construct a time zone. NOTE: use IDs instead tzIdx = self.left.ui.timeZoneComboBox.currentIndex() timeZone = self.timeZones[tzIdx] dateTime = QDateTime(self.left.ui.dateEdit.date(), self.left.ui.timeEdit.time(), timeZone) self.theSun.recalculate(dateTime, longitude, latitude, treeHeight) self.left.ui.timeUTCLineEdit.setText(self.theSun.dateTimeUtc.toString(Qt.ISODate)) self.left.ui.jDLineEdit.setText(str(self.theSun.JD)) self.left.ui.timeVariableNLineEdit.setText(str(self.theSun.n)) self.left.ui.LVariableLineEdit.setText(str(self.theSun.L)) self.left.ui.meanAnomalyGLineEdit.setText(str(self.theSun.g)) self.left.ui.eclipticLengthLineEdit.setText(str(self.theSun.Lambda)) self.left.ui.eclipticSkewLineEdit.setText(u"{}\u00B0 / {} rad".format(self.theSun.epsilon, math.radians(self.theSun.epsilon))) self.left.ui.rightAscensionLineEdit.setText(u"{}\u00B0 / {} rad".format(self.theSun.alpha, math.radians(self.theSun.alpha))) self.left.ui.declinationLineEdit.setText(u"{}\u00B0 / {} rad".format(self.theSun.delta, math.radians(self.theSun.delta))) self.left.ui.jD_0LineEdit.setText(str(self.theSun.JD_0)) self.left.ui.t_0LineEdit.setText(str(self.theSun.T_0)) self.left.ui.sternzeitH_GLineEdit.setText(str(self.theSun.ThetaH_G)) self.left.ui.greenwichStundenwinkelFP_GLineEdit.setText(str(self.theSun.Theta_G)) self.left.ui.stundenwinkelFrHlingspunktLineEdit.setText(str(self.theSun.Theta)) self.left.ui.stundenwinkelLineEdit.setText(str(self.theSun.tau)) self.left.ui.azimutALineEdit.setText(u"{:.1f}\u00B0".format(self.theSun.azimut)) self.left.ui.sunHeightHLineEdit.setText(u"{:.1f}\u00B0".format(math.degrees(self.theSun.sunHeight))) self.left.ui.shadowLengthLineEdit.setText("{:.1f} m".format(self.theSun.shadowLength)) self.right.setAngle(self.theSun.azimut) # shadowAngle) self.right.setShadowLength(self.theSun.shadowLength)
def set_duration(self, ms): """set duration text :param ms: time mm:ss """ m, s = parse_ms(ms) # deal minute and second to QTime arguments duration = QTime(0, m, s) print(m,s) self.duration_text = duration.toString('mm:ss')
def update_state(self, ms): """update current state in progress Label :param ms: time mm:ss """ m, s = parse_ms(ms) position = QTime(0, m, s) position_text = position.toString('mm:ss') self.setText(position_text + '/' + self.duration_text)
class Timer(QLCDNumber): textChanged = pyqtSignal(str) started = pyqtSignal() stopped = pyqtSignal() reset_ = pyqtSignal() def __init__(self, parent=None): super().__init__(parent) self.timer = QTimer() self.timer.timeout.connect(self.tick) self.reset() def start(self): self.timer.start(1000) self.started.emit() def stop(self): self.timer.stop() self.stopped.emit() def reset(self): self.time = QTime(0, 0) self.display(self.time.toString()) self.reset_.emit() def isRunning(self): return self.timer.isActive() def text(self): if self.time.hour() == 0: return self.time.toString('mm:ss') else: return self.time.toString('h:mm:ss') def seconds(self): return self.time.hour() * 3600 + self.time.minute() * 60 + self.time.second() def tick(self): self.time = self.time.addSecs(1) text = self.text() if len(text) != self.digitCount(): self.setDigitCount(len(text)) self.display(text) self.textChanged.emit(text)
def added(self, added): """Saves music info in musicOrder.""" for name, index in zip( self.musicOrder[self.playlist.mediaCount() - added:], range(self.playlist.mediaCount() - added, len(self.musicOrder))): name = name[0] artist = self.getArtist(name)[0] title = self.getTitle(name)[0] album = self.getAlbum(name)[0] seconds = self.getDuration(name) duration = QTime(0, seconds // 60, seconds % 60) duration = duration.toString('mm:ss') self.musicOrder[index].extend( [artist, title, album, duration])
def add_item(self, song_model): music_item = QTableWidgetItem(song_model.title) album_item = QTableWidgetItem(song_model.album_name) artist_item = QTableWidgetItem(song_model.artists_name) m, s = parse_ms(song_model.length) duration = QTime(0, m, s) length_item = QTableWidgetItem(duration.toString()) row = self.rowCount() self.setRowCount(row + 1) self.setItem(row, 1, music_item) self.setItem(row, 2, artist_item) self.setItem(row, 3, album_item) self.setItem(row, 4, length_item) self.songs.append(song_model)
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 positionChanged(self, value): """Update duration label according to value.""" if not self.positionSliderClicked: self.positionSliderClicked = True self.positionSlider.setValue(value) self.positionSliderClicked = False songIndex = self.playlist.currentIndex() if songIndex >= 0: duration = self.playlistTable.item( self.playlist.currentIndex(), 3).text() currentSeconds = value // 1000 currentTime = QTime(0, currentSeconds // 60, currentSeconds % 60) time = '{} / {}'.format( currentTime.toString('mm:ss'), duration) else: time = '00:00 / 00:00' self.durationLabel.setText(time)
def add_item(self, song_model): music_item = QTableWidgetItem(song_model.title) album_item = QTableWidgetItem(song_model.album_name) artist_item = QTableWidgetItem(song_model.artists_name) m, s = parse_ms(song_model.length) duration = QTime(0, m, s) length_item = QTableWidgetItem(duration.toString('mm:ss')) row = self.rowCount() self.setRowCount(row + 1) self.setItem(row, 1, music_item) self.setItem(row, 2, artist_item) self.setItem(row, 3, album_item) self.setItem(row, 4, length_item) cell_widget = _TagCellWidget(self._app) if NSongModel.local_exists(song_model): cell_widget.set_download_tag() self.setCellWidget(row, 5, cell_widget) self.songs.append(song_model)
def update_state(self, ms): m, s = parse_ms(ms) position = QTime(0, m, s) position_text = position.toString('mm:ss') self.setText(position_text + '/' + self.duration_text)
def set_duration(self, ms): m, s = parse_ms(ms) duration = QTime(0, m, s) self.duration_text = duration.toString('mm:ss')
class Main_Page(QMainWindow, Ui_MainWindow, QWidget): def __init__(self, h, m, s, window): super().__init__() self.setWindowTitle('Таймер') with open("changes.txt", "rt", encoding="utf8") as f: text = f.read().split(';') color = text[0].replace('(', '').replace(')', '') self.note = text[1] color = [int(i) for i in color.split(', ')] current_color = QColor(color[0], color[1], color[2], color[3]) self.setStyleSheet("QMainWindow { background-color: %s }" % current_color.name()) self.h = h self.m = m self.s = s self.window = window self.play_check = False self.setupUi(self) self.setGeometry(300, 100, 800, 600) self.current_timer = QTimer(self) self.current_timer.setSingleShot(True) self.current_timer.timeout.connect(self.runTime) self.current_timer.start(100) self.Pause.clicked.connect(self.pauseTime) self.Stop.clicked.connect(self.stopTime) self.Melody.clicked.connect(self.open_mel_win) def runTime(self): self.t1 = QTime(self.h, self.m, self.s, 0) self.timer = QTimer(self) self.timer.timeout.connect(self.showTime) self.timer.start(1000) self.showTime() def showTime(self): if [self.t1.hour(), self.t1.minute(), self.t1.second()] == [0, 0, 0]: self.timer.stop() self.Melody.setEnabled(False) if self.note != '': self.Melody.setText(self.note) self.Pause.setEnabled(False) mixer.init() mixer.music.load(self.window.mel.ringtone) self.play_check = True mixer.music.play(-1) text = self.t1.toString('hh:mm:ss') if (self.t1.second() % 2) != 0: text = text[:2] + ' ' + text[3:5] + ' ' + text[6:] self.t1 = self.t1.addSecs(-1) self.Time.display(text) def pauseTime(self): if self.timer.isActive(): self.timer.stop() self.Pause.setText('Дальше') else: self.Pause.setText('Пауза') milisec_timer = QTimer(self) milisec_timer.setSingleShot(True) self.h = self.t1.hour() self.m = self.t1.minute() self.s = self.t1.second() milisec_timer.start(500) milisec_timer.timeout.connect(self.runTime) def stopTime(self): if self.play_check: mixer.music.stop() self.timer.stop() self.Pause.setDisabled(False) self.Melody.setDisabled(False) self.current_timer.stop() self.hide() self.window.show() def open_mel_win(self): self.window.mel.show()
class Ten(QWidget): def __init__(self, parent=None): super().__init__(parent) self._START = '&START' self._STOP = 'S&TOP' self._RESET = '&RESET' self._FORMAT = 'hh:mm:ss.zzz' self._widgets() self._layout() self._properties() self._connections() def _widgets(self): self.shiverTimer = QTime(0, 0, 0) self.timer = QTimer() self.timerLCDNumber = QLCDNumber() self.timerLCDNumber.setDigitCount(12) self.timerLCDNumber.display("00:00:00.000") self.stortPushButton = QPushButton(self._START) self.resetPushButton = QPushButton(self._RESET) def _layout(self): grid = QGridLayout() grid.addWidget(self.timerLCDNumber, 0, 0, 1, 2) grid.addWidget(self.stortPushButton, 1, 0) grid.addWidget(self.resetPushButton, 1, 1) self.setLayout(grid) def _properties(self): self.resize(350, 125) self.setWindowTitle('{} {}'.format(__title__, __version__)) self.setWindowFlags(Qt.MSWindowsFixedSizeDialogHint) def _connections(self): self.timer.timeout.connect(self.showStopwatch) self.stortPushButton.clicked.connect(self.on_stortPushButton_clicked) self.resetPushButton.clicked.connect(self.on_resetPushButton_clicked) def showStopwatch(self): """ Event handler for showing elapsed time, just like a stopwatch """ self.shiverTimer = self.shiverTimer.addMSecs(1) text = self.shiverTimer.toString(self._FORMAT) self.timerLCDNumber.display(text) def on_stortPushButton_clicked(self): if self.stortPushButton.text() == self._START: self.timer.start(1) # Start the timer self.stortPushButton.setText(self._STOP) else: self.timer.stop() # Stop the timer self.stortPushButton.setText(self._START) def on_resetPushButton_clicked(self): self.timer.stop() self.shiverTimer = QTime(0, 0, 0) self.timerLCDNumber.display(self.shiverTimer.toString(self._FORMAT)) if self.stortPushButton.text() == self._STOP: self.stortPushButton.setText(self._START)
def durationChanged(self, duration): self.positionSlider.setRange(0, duration) mtime = QTime(0,0,0,0) mtime = mtime.addMSecs(self.mediaPlayer.duration()) self.elbl.setText(mtime.toString())
def position_changed(self, position): self.ui.horizontalSlider_Game_Time.setSliderPosition(position) time = QTime(0, 0) time = time.addMSecs(position) self.ui.label_Game_Position.setText(time.toString("m:ss"))
def duration_changed(self, duration): self.ui.horizontalSlider_Game_Time.setRange(0, duration) time = QTime(0, 0) time = time.addMSecs(duration) self.ui.label_Game_Duration.setText(time.toString("m:ss"))
def on_duration_changed(self, duration): m, s = parse_ms(duration) t = QTime(0, m, s) self.duration_label.setText(t.toString('mm:ss'))
def on_position_changed(self, position): m, s = parse_ms(position) t = QTime(0, m, s) self.position_label.setText(t.toString('mm:ss'))
class PomodoroWindow(CenterWindow): def __init__(self, controller, issue_key, issue_title, tray_icon): super().__init__() self.center() self.setStyleSheet(QSS) self.controller = controller self.tray_icon = tray_icon if not os.path.exists(LOGGED_TIME_DIR): os.mkdir(LOGGED_TIME_DIR) self.LOG_PATH = os.path.join( LOGGED_TIME_DIR, '{}.txt'.format(issue_key) ) self.setWindowTitle('Pomodoro Timer') self.settings = QSettings('Spherical', 'Jira Quick Reporter') pomodoro_settings = int(self.settings.value(POMODORO, 25)) long_break_settings = int(self.settings.value(LONG_BREAK, 15)) short_break_settings = int(self.settings.value(SHORT_BREAK, 5)) self.time_dict = dict( short=QTime(0, short_break_settings, 0), long=QTime(0, long_break_settings, 0), pomodoro=QTime(0, pomodoro_settings, 0) ) self.issue_key = issue_key self.issue_title = issue_title self.pomodoros_count = 0 self.current_time_name = POMODORO self.is_active_timer = False self.logged_time = QTime(0, 0, 0) self.time = self.time_dict[POMODORO] self.time_in_seconds = QTime(0, 0, 0).secsTo(self.time) self.timer_box = QVBoxLayout() self.main_box = QHBoxLayout() self.setLayout(self.main_box) self.issue_label = QLabel( '{}: {}'.format(self.issue_key, self.issue_title) ) self.issue_label.setAlignment(Qt.AlignCenter) self.issue_label.setObjectName('issue_label') self.issue_label.setWordWrap(True) self.issue_label.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Fixed ) self.pbar = QProgressBar() self.pbar.setRange(0, self.time_in_seconds) self.pbar.setValue(0) self.pbar.setTextVisible(False) self.timer = QTimer() self.timer.timeout.connect(self.handle_timer) self.time_label = QLabel() self.time_label.setObjectName('time_label') self.time_label.setText(self.time.toString('mm:ss')) self.time_label.setAlignment(Qt.AlignCenter) self.btns_box = QHBoxLayout() self.start_btn = QPushButton('Start') self.start_btn.clicked.connect(self.toggle_timer) self.stop_btn = QPushButton('Stop') self.stop_btn.clicked.connect(self.toggle_timer) self.logwork_btn = QPushButton('Log work') self.logwork_btn.clicked.connect( lambda: self.controller.open_time_log(issue_key) ) self.logwork_btn.setEnabled(False) self.btns_box.addWidget(self.start_btn) self.btns_box.addWidget(self.stop_btn) self.btns_box.addWidget(self.logwork_btn) self.pomodoros_box = QHBoxLayout() self.pomodoros_box.setSpacing(5) self.pomodoros_count_label = QLabel() self.pomodoros_count_label.setObjectName('pomodoros_count') self.timer_box.addWidget(self.issue_label) self.timer_box.addStretch() self.timer_box.addWidget(self.time_label) self.timer_box.addWidget(self.pbar, Qt.AlignCenter) self.timer_box.addLayout(self.btns_box) self.timer_box.addLayout(self.pomodoros_box) self.timer_box.addStretch() self.main_box.addLayout(self.timer_box) self.action_show_time = QAction(self) self.action_show_time.setEnabled(False) self.action_open_timer = QAction('Open timer', self) self.action_open_timer.triggered.connect(self.show) self.action_quit_timer = QAction('Quit timer', self) self.action_quit_timer.triggered.connect(self.quit) self.action_settings = QAction('Settings', self) self.settings_window = Settings(self) self.action_settings.triggered.connect(self.settings_window.show) self.action_reset = QAction('Reset timer', self) self.action_reset.triggered.connect(self.reset_timer) self.action_start_timer = QAction('Start', self) self.action_start_timer.triggered.connect(self.toggle_timer) self.action_stop_timer = QAction('Stop', self) self.action_stop_timer.triggered.connect(self.toggle_timer) self.action_log_work = QAction('Log work', self) self.action_log_work.triggered.connect( lambda: self.controller.open_time_log(issue_key) ) self.action_log_work.setEnabled(False) self.tray_icon.contextMenu().addSeparator() self.tray_icon.contextMenu().addAction(self.action_show_time) self.action_show_time.setText(self.time.toString('mm:ss')) self.tray_icon.contextMenu().addAction(self.action_open_timer) self.tray_icon.contextMenu().addAction(self.action_settings) self.tray_icon.contextMenu().addAction(self.action_quit_timer) self.tray_icon.contextMenu().addSeparator() self.tray_icon.contextMenu().addAction(self.action_start_timer) self.tray_icon.contextMenu().addAction(self.action_stop_timer) self.tray_icon.contextMenu().addAction(self.action_reset) self.tray_icon.contextMenu().addAction(self.action_log_work) def log_work_if_file_exists(self): if os.path.exists(self.LOG_PATH): reply = QMessageBox.question( self, 'Warning', 'You have not logged your work.\n Do you want to log it?', QMessageBox.Yes | QMessageBox.No ) if reply == QMessageBox.Yes: self.controller.open_time_log(self.issue_key) else: os.remove(self.LOG_PATH) def update_time_from_settings(self, minutes, time_name): if self.current_time_name != time_name: self.time_dict[time_name].setHMS(0, minutes, 0) elif not self.is_active_timer: self.time_dict[time_name].setHMS(0, minutes, 0) self.update_timer() elif self.time_dict[time_name].minute() > minutes: spent_time_seconds = self.time.secsTo(self.time_dict[time_name]) if minutes <= spent_time_seconds // 60: self.stop_timer() QSound.play(RING_SOUND_PATH) self.set_timer() else: time_diff = self.time_dict[time_name].minute() - minutes self.change_timer(minutes, -time_diff) elif self.time_dict[time_name].minute() < minutes: time_diff = minutes - self.time_dict[time_name].minute() self.change_timer(minutes, time_diff) def change_timer(self, minutes, time_diff): self.time_dict[self.current_time_name].setHMS(0, minutes, 0) self.time = self.time.addSecs(time_diff * 60) self.time_in_seconds = minutes * 60 self.pbar.setMaximum(self.time_in_seconds) self.time_label.setText(self.time.toString('mm:ss')) self.action_show_time.setText(self.time.toString('mm:ss')) def handle_timer(self): """ Updates timer label and progress bar every second until time is over """ value = self.pbar.value() if value < self.time_in_seconds: value += 1 self.pbar.setValue(value) self.time = self.time.addSecs(-1) self.time_label.setText(self.time.toString('mm:ss')) self.action_show_time.setText(self.time.toString('mm:ss')) if not value % 60: self.log_time() else: self.stop_timer() QSound.play(RING_SOUND_PATH) if self.current_time_name != POMODORO: self.tray_icon.showMessage( 'Pomodoro', 'Your break is over', msecs=2000) self.set_timer() def update_timer(self): self.time_in_seconds = QTime(0, 0, 0).secsTo(self.time) self.pbar.setMaximum(self.time_in_seconds) self.pbar.setValue(0) self.time_label.setText(self.time.toString('mm:ss')) self.action_show_time.setText(self.time.toString('mm:ss')) def set_pomodoro_timer(self): self.is_active_timer = False self.current_time_name = POMODORO self.time = self.time_dict[POMODORO] self.update_timer() def set_pomodoro_count(self): """ Set pomodoro mark and number of past pomodoros """ self.clear_pomodoros() label = QLabel() pixmap = QPixmap(POMODORO_MARK_PATH) label.setPixmap(pixmap) self.pomodoros_box.addWidget(self.pomodoros_count_label) self.pomodoros_count_label.setSizePolicy( QSizePolicy.Fixed, QSizePolicy.Expanding ) self.pomodoros_box.addWidget(label) self.pomodoros_count_label.setText(str(self.pomodoros_count)) def set_pomodoro_img(self): label = QLabel() pixmap = QPixmap(POMODORO_MARK_PATH) label.setPixmap(pixmap) if self.pomodoros_count > 1: self.pomodoros_box.itemAt( self.pomodoros_count - 2 ).widget().setSizePolicy( QSizePolicy.Fixed, QSizePolicy.Expanding ) self.pomodoros_box.addWidget(label) def clear_pomodoros(self): for _ in range(self.pomodoros_box.count()): self.pomodoros_box.itemAt(0).widget().setParent(None) def toggle_timer(self): sender = self.sender().text() if sender in ['Start', 'Resume']: self.start_timer() elif sender == 'Pause': self.pause_timer() else: self.stop_timer() self.set_pomodoro_timer() def log_time(self): self.logged_time = self.logged_time.addSecs(60) with open(self.LOG_PATH, 'w') as log_file: log_file.write(self.logged_time.toString('h:m')) def start_timer(self): self.is_active_timer = True # change style before a break if self.current_time_name != POMODORO: self.issue_label.setObjectName('issue_label_break') self.issue_label.setStyleSheet('issue_label_break') self.pbar.setObjectName('break') self.pbar.setStyleSheet('break') self.stop_btn.hide() self.start_btn.setText('Stop') self.action_start_timer.setEnabled(False) else: self.tray_icon.showMessage( 'Pomodoro', 'Focus on your task', msecs=2000 ) self.start_btn.setText('Pause') self.action_start_timer.setText('Pause') self.logwork_btn.setEnabled(False) self.action_log_work.setEnabled(False) self.timer.start(1000) def stop_timer(self): self.timer.stop() self.is_active_timer = False self.start_btn.setText('Start') self.action_start_timer.setText('Start') self.logwork_btn.setEnabled(True) self.action_log_work.setEnabled(True) if self.current_time_name != POMODORO: self.stop_btn.show() self.action_start_timer.setEnabled(True) # change style after a break self.issue_label.setObjectName('issue_label') self.issue_label.setStyleSheet('issue_label') self.pbar.setObjectName('') self.pbar.setStyleSheet('') def pause_timer(self): self.timer.stop() self.start_btn.setText('Resume') self.action_start_timer.setText('Resume') self.logwork_btn.setEnabled(True) self.action_log_work.setEnabled(True) def reset_timer(self): self.logwork_btn.setEnabled(False) self.action_log_work.setEnabled(False) self.stop_timer() self.pomodoros_count = 0 self.logged_time.setHMS(0, 0, 0) self.clear_pomodoros() self.set_pomodoro_timer() if os.path.exists(self.LOG_PATH): os.remove(self.LOG_PATH) def set_pomodoro_mark(self): if self.pomodoros_count < 5: self.set_pomodoro_img() elif self.pomodoros_count == 5: self.set_pomodoro_count() else: self.pomodoros_count_label.setText( str(self.pomodoros_count) ) def set_timer(self): """ In this method decides which timer will go next """ # if pomodoro time's up if self.current_time_name == POMODORO: self.pomodoros_count += 1 self.set_pomodoro_mark() # if four pomodoros have completed if not self.pomodoros_count % 4: self.current_time_name = LONG_BREAK else: self.current_time_name = SHORT_BREAK dialog = BreakDialog(self.current_time_name) # close dialog after 4 seconds QTimer.singleShot(4000, dialog.close) # get break name (short, long or skip) from dialog self.current_time_name = dialog.exec() if self.current_time_name != POMODORO: self.time = self.time_dict[self.current_time_name] self.update_timer() self.start_timer() return # if break time's up self.set_pomodoro_timer() def quit(self): if os.path.exists(self.LOG_PATH): reply = QMessageBox.question( self, 'Warning', 'You did not log your work. \nAre you sure you want to exit?', QMessageBox.Yes, QMessageBox.No ) if reply == QMessageBox.No: return False self.settings.setValue( POMODORO, self.time_dict[POMODORO].minute() ) self.settings.setValue( LONG_BREAK, self.time_dict[LONG_BREAK].minute() ) self.settings.setValue( SHORT_BREAK, self.time_dict[SHORT_BREAK].minute() ) self.settings.sync() self.setAttribute(Qt.WA_DeleteOnClose, True) self.close() return True def closeEvent(self, event): if self.testAttribute(Qt.WA_DeleteOnClose): self.controller.pomodoro_view = None event.accept() else: event.ignore() self.hide()
def on_player_position_changed(cls, ms): time_text = QTime(0, (ms / 60000) % 60, (ms / 1000) % 60) cls.ui.SONG_COUNTDOWN_LABEL.setText(time_text.toString("mm:ss")) cls.ui.SONG_PROGRESS_SLIDER.setValue(ms / 1000) cls.controller.desktop_mini.content.set_value(ms / 1000) cls.controller.lyric_widget.show_lyric_while_visible(ms)