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 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 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'))
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_duration_changed(self, duration):
m, s = parse_ms(duration)
t = QTime(0, m, s)
self.duration_label.setText(t.toString('mm:ss'))
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)
