class Clock(QLabel):
def __init__(self):
super().__init__()
self.time_left = QTime(0, 0)
self.timer = QTimer(self)
self.timer.timeout.connect(self.update_time)
self.is_paused = True
self.is_set = False
def set_time(self, minutes, seconds=0):
self.stop()
self.time_left = QTime(0, minutes, seconds)
self.setText(self.time_left.toString('mm:ss'))
self.is_set = True
self.setStyleSheet('')
def start(self):
if self.is_paused and self.is_set:
self.timer.start(1000)
self.is_paused = False
def stop(self):
if not self.is_paused:
self.timer.stop()
self.is_paused = True
def update_time(self):
self.time_left = self.time_left.addSecs(-1)
if self.time_left.minute() == 0 and self.time_left.second() == 0:
self.stop()
self.is_set = False
self.setStyleSheet('QLabel { color: red}')
self.setText(self.time_left.toString('mm:ss'))
def timerEvent(self):
global time
timer = QTimer()
time = QTime(0, 0, 0)
prev_time = QTime(0, 0, 0)
prev_time = time
time = time.addSecs(1)
print(time.toString("hh:mm:ss"))
print("Entered")
timer.start(100)
timer.setInterval(2000)
timer.timeout.connect(self.timerEvent)
def utc(self, rise_set, what):
''' Convert sun rise/set from UTC to local time
'rise_set' is 'Sunrise' or 'Sunset when it is for weatherdata
or the index of hour in day forecast when dayforecast'''
listtotime = ''
# Create a list ['h', 'm', 's'] and pass it to QTime
if what == 'weatherdata':
listtotime = self.weatherdata[rise_set].split('T')[1].split(':')
elif what == 'dayforecast':
listtotime = self.tree_day[4][rise_set].get('from').split(
'T')[1].split(':')
suntime = QTime(int(listtotime[0]), int(listtotime[1]), int(
listtotime[2]))
# add the diff UTC-local in seconds
utc_time = suntime.addSecs(time.localtime().tm_gmtoff)
utc_time_str = utc_time.toString()
return utc_time_str
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 utc(self, rise_set, what):
''' Convert sun rise/set from UTC to local time
'rise_set' is 'Sunrise' or 'Sunset' when it is for weatherdata
or the index of hour in day forecast when dayforecast'''
listtotime = ''
# Create a list ['h', 'm', 's'] and pass it to QTime
if what == 'weatherdata':
listtotime = self.weatherdata[rise_set].split('T')[1].split(':')
elif what == 'dayforecast':
if not self.json_data_bool:
listtotime = self.tree_day[4][rise_set].get('from').split(
'T')[1].split(':')
else:
listtotime = self.tree_day['list'][rise_set]['dt_txt'][
10:].split(':')
suntime = QTime(int(listtotime[0]), int(listtotime[1]),
int(listtotime[2]))
# add the diff UTC-local in seconds
utc_time = suntime.addSecs(time.localtime().tm_gmtoff)
utc_time_str = utc_time.toString()
return utc_time_str
class Interval_timer:
def __init__(self, main_time, label, tray, outer_class, rpc, subject):
self.outer_class = outer_class
self.tray = tray
self.label = label
self.main_time = main_time
self.time = QTime(0, main_time, 0)
self.RPC = rpc
self.subject = subject
def timerEvent(self):
self.time = self.time.addSecs(-1)
self.label.setText(self.time.toString("mm:ss"))
if self.time.secsTo(QTime(0, 0, 0)) == 0:
print("Break timer stopped")
self.tray.showMessage("Tomatime", "Break time's up",
self.tray.icon(), 4000)
self.clearTimer()
self.outer_class.timer.timeout.disconnect(self.timerEvent)
self.outer_class.timer.timeout.connect(
self.outer_class.timerEvent)
print("Returning to focus timer")
self.outer_class.round += 1
self.outer_class.updateDiscord("Studying")
return print(self.time.toString("mm:ss"), " Break timer")
def startTimer(self):
print("Starting secondary timer")
self.outer_class.timer.timeout.connect(self.timerEvent)
self.outer_class.updateDiscord("Taking a break")
def clearTimer(self):
print("Clearing break timer")
self.time = QTime(0, self.main_time, 0)
self.label.setText(self.time.toString("mm:ss"))
class PomoTimer:
def __init__(self, times, label, tray, rpc, subject):
self.subject = subject
self.tray = tray
self.label = label
self.main_time = times[0]
self.time = QTime(0, self.main_time, 0)
self.timer = QTimer()
self.timer.setInterval(1000)
self.timer.timeout.connect(self.timerEvent)
self.rep = 0
self.RPC = rpc
self.short_break = self.Interval_timer(times[1], self.label, self.tray,
self, self.RPC, self.subject)
self.long_break = self.Interval_timer(times[2], self.label, self.tray,
self, self.RPC, self.subject)
self.round = 1
class Interval_timer:
def __init__(self, main_time, label, tray, outer_class, rpc, subject):
self.outer_class = outer_class
self.tray = tray
self.label = label
self.main_time = main_time
self.time = QTime(0, main_time, 0)
self.RPC = rpc
self.subject = subject
def timerEvent(self):
self.time = self.time.addSecs(-1)
self.label.setText(self.time.toString("mm:ss"))
if self.time.secsTo(QTime(0, 0, 0)) == 0:
print("Break timer stopped")
self.tray.showMessage("Tomatime", "Break time's up",
self.tray.icon(), 4000)
self.clearTimer()
self.outer_class.timer.timeout.disconnect(self.timerEvent)
self.outer_class.timer.timeout.connect(
self.outer_class.timerEvent)
print("Returning to focus timer")
self.outer_class.round += 1
self.outer_class.updateDiscord("Studying")
return print(self.time.toString("mm:ss"), " Break timer")
def startTimer(self):
print("Starting secondary timer")
self.outer_class.timer.timeout.connect(self.timerEvent)
self.outer_class.updateDiscord("Taking a break")
def clearTimer(self):
print("Clearing break timer")
self.time = QTime(0, self.main_time, 0)
self.label.setText(self.time.toString("mm:ss"))
def timerEvent(self):
self.time = self.time.addSecs(-1)
self.label.setText(self.time.toString("mm:ss"))
if self.time.secsTo(QTime(0, 0, 0)) == 0:
self.rep += 1
self.timer.timeout.disconnect(self.timerEvent)
self.clearTimer()
print("Focus time's up")
self.tray.showMessage("Tomatime", "Focus time's up",
self.tray.icon(), 4000)
if self.rep == 3:
self.rep = 0
self.long_break.startTimer()
return print("Starting long break timer")
else:
self.short_break.startTimer()
return print("Starting short break timer")
return print(self.time.toString("mm:ss"), (" Focus Timer Ticking"))
def startTimer(self):
self.timer.start()
print(self.timer.interval())
self.updateDiscord("Studying")
def clearTimer(self):
self.time = QTime(0, self.main_time, 0)
def pauseTimer(self):
self.timer.stop()
try:
self.RPC.update(state=f"Studying - Round {self.round}",
details="Paused",
large_image="fsidfsd")
except:
print("No Discord app running")
def resetTimer(self):
self.pauseTimer()
self.short_break.clearTimer()
self.long_break.clearTimer()
self.clearTimer()
self.label.setText(str(self.main_time) + ":00")
try:
self.timer.timeout.disconnect(self.short_break.timerEvent)
except:
pass
try:
self.timer.timeout.disconnect(self.long_break.timerEvent)
except:
pass
try:
self.timer.timeout.disconnect(self.timerEvent)
except:
pass
self.timer.timeout.connect(self.timerEvent)
def epochTime(self, mins, second):
orig = datetime.datetime.fromtimestamp(time.time())
new = orig + datetime.timedelta(minutes=mins, seconds=second)
return time.mktime(new.timetuple())
def updateDiscord(self, info):
try:
self.RPC.update(
state=f"Studying {self.subject} - Round {self.round}",
details=info,
large_image="fsidfsd",
end=self.epochTime(self.time.minute(), self.time.second()))
except:
print("No Discord app running")
class Trainer(QWidget):
num = 0
max_num = 0
correct = 0
dfn = ''
res = ''
ans = ''
wl1 = []
wl2 = []
ms = '00:00:00'
filename = ''
revl = ''
#processing
def processing(self):
#setup variables
self.num = 0
self.max_num = 0
self.correct = 0
self.ms = '00:00:00'
self.wl1 = []
self.filename = ''
self.revl = ''
with open(f_path + 'test.csv', 'r', encoding='utf-8') as f2:
reader2 = csv.reader(f2)
for row in reader2:
word = ''
word = row[0]
hint = ''
hint = row[1]
self.dfn = hint
self.wl1.append([word, hint])
self.max_num += 1
#review
def reviewing(self):
#setup variables
self.num = 0
self.max_num = 0
self.correct = 0
self.ms = '00:00:00'
self.wl2 = []
self.filename = ''
self.revl = ''
with open(f_path + 'review_test.csv', 'r', encoding='utf-8') as f3:
reader3 = csv.reader(f3)
for row in reader3:
word = ''
word = row[0]
hint = ''
hint = row[1]
self.dfn = hint
self.wl2.append([word, hint])
self.max_num += 1
#next question
def nextQ1(self, i):
if i < self.max_num:
self.dfn = self.wl1[i][1]
self.ans = self.wl1[i][0]
self.label1.setText(str(self.dfn))
self.label2.setText('')
self.label_d.setText(str(self.num + 1) + '/' + str(self.max_num))
else:
#setup result
self.max_n.setText(str(self.max_num))
self.corr.setText(str(self.correct))
self.percentage()
self.min_sec.setText(str(self.ms))
#print result
self.rt = self.per.text() + '%'
self.tm = self.min_sec.text()
b.close()
self.msgbox = QMessageBox.about(
self, 'Results',
'Accuracy: ' + self.rt + '\n' + 'Time: ' + self.tm)
self.time = QTime(0, 0, 0)
#reboot
b.close()
subprocess.Popen([sys.executable, filename])
#next question
def nextQ2(self, i):
if i < self.max_num:
self.dfn = self.wl2[i][1]
self.ans = self.wl2[i][0]
self.label1.setText(str(self.dfn))
self.label2.setText('')
self.label_d.setText(str(self.num + 1) + '/' + str(self.max_num))
else:
#setup result
self.max_n.setText(str(self.max_num))
self.corr.setText(str(self.correct))
self.percentage()
self.min_sec.setText(str(self.ms))
#print result
self.rt = self.per.text() + '%'
self.tm = self.min_sec.text()
b.close()
self.msgbox = QMessageBox.about(
self, 'Results',
'Accuracy: ' + self.rt + '\n' + 'Time: ' + self.tm)
self.time = QTime(0, 0, 0)
#reboot
b.close()
subprocess.Popen([sys.executable, filename])
#calculate
def percentage(self):
c = self.correct
t = self.max_num
if (int(c) > 0 and int(t) > 0):
p = float(c) / float(t) * 100
else:
p = 0.0
self.per.setText(str(round(p, 2)))
#initiate
def __init__(self):
super().__init__()
#setup icon
self.setWindowIcon(QIcon(scriptDir + os.path.sep + 'icon.png'))
self.initUI()
#center/size & show
width = QDesktopWidget().width() * 0.4
height = QDesktopWidget().height() * 0.4
self.setMinimumSize(width, height)
self.center()
self.setWindowTitle('Vocab Trainer' + self.filename)
#initiate function
def initUI(self):
#textbox & sizing font
self.textbox1 = QLineEdit()
self.font0 = self.textbox1.font()
self.font0.setPointSize(18)
self.textbox1.setFont(self.font0)
#text
self.label1 = QLabel(self.dfn)
self.label1.setFont(self.font0)
self.label1.setWordWrap(True)
self.label1.setStyleSheet('background-color: #F5F5F5')
self.label2 = QLabel('')
self.label2.setFont(self.font0)
self.label2.setStyleSheet('color: #FF0000')
#variable
self.max_n = QLabel()
self.corr = QLabel()
self.per = QLabel()
self.min_sec = QLabel()
#button
self.btn = QPushButton('Enter')
self.btn.setFont(self.font0)
self.textbox1.returnPressed.connect(self.btn.click)
#timer & display
self.label_t = QLabel(self.ms)
self.label_t.setFont(Main().font1)
self.label_d = QLabel()
self.label_d.setFont(Main().font1)
self.label_d.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.timer = QTimer()
self.time = QTime(0, 0, 0)
self.timer.timeout.connect(self.timerEvent)
self.timer.start(1000)
#timer & display
hbox = QHBoxLayout()
hbox.addWidget(self.label_t, 0)
hbox.addWidget(self.label_d, 0)
#setup grid
grid1 = QGridLayout()
grid1.setSpacing(50)
grid1.addLayout(hbox, 1, 0, 1, 0)
grid1.addWidget(self.label1)
grid1.addWidget(self.label2)
grid1.addWidget(self.textbox1)
grid1.addWidget(self.btn)
self.setLayout(grid1)
#setup timer
def timerEvent(self):
if self.isVisible(): self.time = self.time.addSecs(1)
self.ms = self.time.toString('hh:mm:ss')
self.label_t.setText(self.ms)
#center gui
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
#leave confirm
def closeEvent(self, event):
if self.num < self.max_num:
reply = QMessageBox.question(self, 'Vocab Trainer' + self.filename,
"Are you sure to quit?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
if reply == QMessageBox.Yes:
event.accept()
else:
event.ignore()
def keyPressEvent(self, event):
#Close application from escape key.
if event.key() == Qt.Key_Escape:
#reboot
b.close()
subprocess.Popen([sys.executable, filename])
#pressed enter
def on_click1(self):
self.res = self.textbox1.text()
if self.res != self.ans:
self.textbox1.clear()
self.label2.setText(self.ans)
else:
if self.label2.text() == '':
self.correct += 1
else:
self.correct += 0
with open(wl_path + 'review.csv', 'w', encoding='utf-8') as f3:
self.revl += (self.ans + ',' + self.dfn + '\n')
f3.write(self.revl)
self.textbox1.clear()
self.label2.setText('')
self.num += 1
self.nextQ1(self.num)
#pressed enter
def on_click2(self):
self.res = self.textbox1.text()
if self.res != self.ans:
self.textbox1.clear()
self.label2.setText(self.ans)
else:
if self.label2.text() == '':
self.correct += 1
else:
self.correct += 0
with open(wl_path + 'review.csv', 'w', encoding='utf-8') as f3:
self.revl += (self.ans + ',' + self.dfn + '\n')
f3.write(self.revl)
self.textbox1.clear()
self.label2.setText('')
self.num += 1
self.nextQ2(self.num)
class MainWidget(QWidget):
show_msg = pyqtSignal()
def __init__(self, formation):
super().__init__()
self.formation = formation
layout = QGridLayout()
self.show_msg.connect(self.show_message)
self.final_string = None
self.table = QTableWidget()
self.table.setFixedWidth(COLUMNS_WIDTH * 4 + 2)
self.table.horizontalHeader().hide()
self.table.verticalHeader().hide()
self.table.setStyleSheet(
"QTableWidget { background-color: #808080; color: white; }")
self.table.setColumnCount(4)
if formation:
self.table.setRowCount(6)
else:
self.table.setRowCount(5)
for i in range(self.table.colorCount()):
self.table.setColumnWidth(i, COLUMNS_WIDTH)
self.timer = QTimer()
self.time = QTime(0, 0)
self.timer.timeout.connect(self.timer_event)
self.timer.start(1000)
timer_item = QTableWidgetItem("00:00")
timer_item.setData(Qt.FontRole, QFont("", 20))
timer_item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
timer_item.setFlags(Qt.NoItemFlags)
self.table.setSpan(0, 0, 1, 4)
self.table.setItem(0, 0, timer_item)
fees_item = QTableWidgetItem("Штрафы")
fees_item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
fees_item.setFlags(Qt.NoItemFlags)
self.table.setSpan(1, 0, 1, 4)
self.table.setItem(1, 0, fees_item)
coll_it = QTableWidgetItem("Столкновения")
coll_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 0, coll_it)
coll_it = QTableWidgetItem("0")
coll_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 1, coll_it)
if formation:
out_it = QTableWidgetItem("Вылеты")
out_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 2, out_it)
out_it = QTableWidgetItem("0")
out_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 3, out_it)
else:
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 2, unu_it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 3, unu_it)
self.table.item(2, 2).setBackground(COLOR_UNUSED)
self.table.item(2, 3).setBackground(COLOR_UNUSED)
self.table.setSpan(3, 0, 1, 4)
zones_it = QTableWidgetItem("Зоны")
zones_it.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
zones_it.setFlags(Qt.NoItemFlags)
self.table.setItem(3, 0, zones_it)
if formation:
self.table.setSpan(4, 0, 2, 1)
self.table.setSpan(4, 1, 2, 1)
self.table.setSpan(4, 2, 2, 1)
self.table.setSpan(4, 3, 2, 1)
n_it = QTableWidgetItem("N")
n_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 0, n_it)
sco_cur_it = QTableWidgetItem("СКО\nтекущее")
sco_cur_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 1, sco_cur_it)
sco_mean_it = QTableWidgetItem("СКО\nсреднее")
sco_mean_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 2, sco_mean_it)
t_it = QTableWidgetItem("Время\nперестроения")
t_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 3, t_it)
else:
# self.table.setSpan(4, 1, 2, 1)
# self.table.setSpan(4, 2, 2, 1)
# self.table.setSpan(4, 3, 2, 1)
n_it = QTableWidgetItem("N")
n_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 0, n_it)
t_it = QTableWidgetItem("Время")
t_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 1, t_it)
f_it = QTableWidgetItem("Штраф")
f_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 2, f_it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(4, 3, unu_it)
self.table.item(4, 3).setBackground(COLOR_UNUSED)
layout.addWidget(self.table)
self.setLayout(layout)
self.add_row()
def timer_event(self):
self.time = self.time.addSecs(1)
timer_item = QTableWidgetItem(self.time.toString("mm:ss"))
timer_item.setData(Qt.FontRole, QFont("", 20))
timer_item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
timer_item.setFlags(Qt.NoItemFlags)
self.table.setItem(0, 0, timer_item)
def add_row(self):
rc = self.table.rowCount()
self.table.insertRow(rc)
if self.formation:
it = QTableWidgetItem(str(rc - 5))
it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 0, it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 1, unu_it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 2, unu_it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 3, unu_it)
else:
it = QTableWidgetItem(str(rc - 4))
it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 0, it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 1, unu_it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 2, unu_it)
unu_it = QTableWidgetItem()
unu_it.setFlags(Qt.NoItemFlags)
self.table.setItem(rc, 3, unu_it)
self.table.item(rc, 3).setBackground(COLOR_UNUSED)
def update_collisions(self, data):
data_it = QTableWidgetItem(str(data))
data_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 1, data_it)
def update_side_time(self, data):
data_it = QTableWidgetItem(str(round(float(data), 2)))
data_it.setFlags(Qt.NoItemFlags)
self.table.setItem(2, 3, data_it)
def update_msd_current(self, data):
data_it = QTableWidgetItem(str(round(float(data), 2)))
data_it.setFlags(Qt.NoItemFlags)
self.table.setItem(self.table.rowCount() - 1, 1, data_it)
def update_msd_overall(self, data):
data_it = QTableWidgetItem(str(round(float(data), 2)))
data_it.setFlags(Qt.NoItemFlags)
self.table.setItem(self.table.rowCount() - 1, 2, data_it)
def update_reformation(self, data):
data_it = QTableWidgetItem(str(round(float(data), 2)))
data_it.setFlags(Qt.NoItemFlags)
self.table.setItem(self.table.rowCount() - 1, 3, data_it)
def update_times(self, data):
data_it = QTableWidgetItem(str(round(float(data), 2)))
data_it.setFlags(Qt.NoItemFlags)
self.table.setItem(self.table.rowCount() - 1, 1, data_it)
def update_passes(self, data):
data_it = QTableWidgetItem(str(round(float(data), 2)))
data_it.setFlags(Qt.NoItemFlags)
self.table.setItem(self.table.rowCount() - 1, 2, data_it)
def collisions_cb(self, data):
self.update_collisions(data.data)
def side_time_cb(self, data):
self.update_side_time(data.data)
def msd_current_cb(self, data):
self.update_msd_current(data.data)
def msd_overall_cb(self, data):
self.update_msd_overall(data.data)
self.add_row()
def reformation_cb(self, data):
self.update_reformation(data.data)
def passes_cb(self, data):
self.update_passes(data.data)
def times_cb(self, data):
self.update_times(data.data)
self.add_row()
# noinspection PyMethodMayBeStatic
def final_cb(self, data):
dds = data.data.split('::')
if len(dds) == 4:
string = "FINAL SCORE: {} \n" \
"___________________________ \n" \
"NOMINATIONS\n" \
"SYNCHRONICITY: {} \n" \
"EFFICIENCY: {} \n" \
"SPEED: {}".format(*tuple(dds))
elif len(dds) == 3:
string = "FINAL SCORE: {} \n" \
"___________________________ \n" \
"NOMINATIONS\n" \
"ACCURACY: {} \n" \
"SPEED: {}".format(*tuple(dds))
else:
string = "BAD DATA"
# print(string)
self.final_string = string
self.show_msg.emit()
def show_message(self):
QMessageBox.information(self.parent(), "RESULT", self.final_string,
QMessageBox.Ok)
class Timer(QWidget):
"""
Timer component. Contains a label and a button
"""
paused = False
def __init__(self, timer_data, style=Style()):
"""
Initialize styling and create its components
:param timer_data: timer value from JSON
:param style: styling object
"""
super().__init__()
# Styling and main layout
self.styles = style
self.box_layout = QHBoxLayout()
self.box_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.box_layout)
# Label (displays the timer value)
self.label = QLabel()
self.label.setStyleSheet(self.styles.timer_label)
self.label.setText("00:00:00")
self.box_layout.addWidget(self.label)
# Button pause/continue
self.button = QPushButton()
self.button.setIconSize(QSize(50, 50))
self.button.setIcon(self.style().standardIcon(getattr(QStyle, "SP_MediaPause")))
self.button.setStyleSheet(self.styles.timer_button)
self.button.clicked.connect(self.btnClicked)
self.box_layout.addWidget(self.button)
# Initialize the clock
self.curr_time = QTime(timer_data[0], timer_data[1], timer_data[2])
self.timer = QTimer()
self.timer.timeout.connect(self.updateTime)
self.timer.start(1000)
def updateTime(self):
"""
Timers callback (called every second to update the timer value)
"""
self.curr_time = self.curr_time.addSecs(1)
self.label.setText(self.curr_time.toString("hh:mm:ss"))
def btnClicked(self):
"""
Pause or continue the timer depending of its status
"""
if self.paused:
self.timer.start()
self.paused = False
self.button.setIcon(self.style().standardIcon(getattr(QStyle, "SP_MediaPause")))
else:
self.timer.stop()
self.paused = True
self.button.setIcon(self.style().standardIcon(getattr(QStyle, "SP_MediaPlay")))
class Device:
def __init__(self, s, d, c, i):
self.media_listener = MediaListener()
self.media_listener._self = s
self.media_listener.index = i
self.status_listener = StatusListener()
self.status_listener._self = s
self.status_listener.index = i
self.connection_listener = ConnectionListener()
self.connection_listener._self = s
self.cast = c
self.index = i
self._self = s
self.device = d
self.live = False
self.muted = False
self.unmute_volume = 0
self.disconnect_volume = 0
self.paused = True
self.playing = False
self.stopping = False
self.rebooting = False
self.catt_process = None
self.directory = None
self.filename = None
self.playback_starting = False
self.playback_just_started = False
self.stopping_timer = QTimer()
self.starting_timer = QTimer()
self.just_started_timer = QTimer()
self.progress_clicked = False
self.catt_read_thread = None
self.progress_timer = QTimer()
self.time = QTime(0, 0, 0)
self.stopping_timer.timeout.connect(lambda: s.on_stopping_timeout(self))
self.starting_timer.timeout.connect(lambda: s.on_starting_timeout(self))
self.just_started_timer.timeout.connect(lambda: s.on_just_started_timeout(self))
self.stopping_timer.setSingleShot(True)
self.starting_timer.setSingleShot(True)
self.just_started_timer.setSingleShot(True)
self.progress_timer.timeout.connect(self.on_progress_tick)
def on_progress_tick(self):
s = self._self
self.time = self.time.addSecs(1)
duration = self.device._cast.media_controller.status.duration
if duration and duration != 0 and time_to_seconds(self.time) >= int(duration):
# If progress is at the end, stop the device progress timer
self.set_state_idle(self.index)
if s.combo_box.currentIndex() == self.index:
# If it is the currently selected device, update the ui
self.update_ui_idle()
if s.combo_box.currentIndex() == self.index:
# Update the ui elements using current progress time
s.progress_label.setText(self.time.toString("hh:mm:ss"))
s.set_progress(time_to_seconds(self.time))
def set_state_playing(self, i, time):
s = self._self
s.set_time(i, int(time))
self.paused = False
self.playing = True
if self.live:
s.stop_timer.emit(i)
self.time.setHMS(0, 0, 0)
else:
s.start_timer.emit(i)
def update_ui_playing(self, time, duration):
s = self._self
if duration != None:
s.progress_slider.setMaximum(duration)
if self.live:
s.skip_forward_button.setEnabled(False)
s.progress_slider.setEnabled(False)
s.progress_label.setText("LIVE")
s.set_icon(s.play_button, "SP_MediaPlay")
else:
s.skip_forward_button.setEnabled(True)
s.progress_slider.setEnabled(True)
s.set_icon(s.play_button, "SP_MediaPause")
s.set_progress(time)
s.progress_label.setText(self.time.toString("hh:mm:ss"))
self.update_text()
def set_state_paused(self, i, time):
s = self._self
s.set_time(i, int(time))
s.stop_timer.emit(i)
self.paused = True
self.playing = True
def update_ui_paused(self, time, duration):
s = self._self
if duration != None:
s.progress_slider.setMaximum(duration)
s.set_progress(time)
s.skip_forward_button.setEnabled(True)
s.progress_slider.setEnabled(True)
s.set_icon(s.play_button, "SP_MediaPlay")
s.progress_label.setText(self.time.toString("hh:mm:ss"))
self.update_text()
def set_state_idle(self, i):
s = self._self
s.stop_timer.emit(i)
self.time.setHMS(0, 0, 0)
self.playing = False
self.paused = True
self.live = False
def update_ui_idle(self):
s = self._self
s.set_progress(0)
s.skip_forward_button.setEnabled(False)
s.progress_slider.setEnabled(False)
s.progress_label.setText(self.time.toString("hh:mm:ss"))
s.set_icon(s.play_button, "SP_MediaPlay")
self.update_text()
def set_dial_value(self):
s = self._self
v = self.device._cast.status.volume_level * 100
s.dial.valueChanged.disconnect(s.on_dial_moved)
if v != 0:
self.unmute_volume = v
s.dial.setValue(v)
s.set_volume_label(v)
s.dial.valueChanged.connect(s.on_dial_moved)
def split_seconds(self, s):
hours = s // 3600
minutes = (s - (hours * 3600)) // 60
seconds = s - ((hours * 3600) + (minutes * 60))
return hours, minutes, seconds
def set_text(self, s, status_text, title):
prefix = ""
if self.live:
prefix = "Streaming"
if prefix and (status_text or title):
prefix = prefix + " - "
if status_text and title:
if status_text in title:
s.status_label.setText(prefix + title)
elif title in status_text:
s.status_label.setText(prefix + status_text)
else:
s.status_label.setText(prefix + status_text + " - " + title)
elif status_text:
s.status_label.setText(prefix + status_text)
elif title:
s.status_label.setText(prefix + title)
elif prefix:
s.status_label.setText(prefix)
elif self.filename == None:
s.status_label.setText("Idle")
def update_text(self):
title = self.device._cast.media_controller.title
status_text = self.device._cast.status.status_text
s = self._self
if not self.playing:
if self.stopping:
s.status_label.setText("Stopping..")
elif self.rebooting:
s.status_label.setText("Rebooting..")
elif (
self.playback_starting == False and self.playback_just_started == False
) or s.status_label.text() == "Stopping..":
s.status_label.setText("Idle")
s.set_icon(s.play_button, "SP_MediaPlay")
else:
self.set_text(s, status_text, title)
return
self.set_text(s, status_text, title)
def kill_catt_process(self):
if self.catt_process == None:
return
if self.catt_read_thread != None:
self.catt_read_thread.cancel()
try:
os.kill(self.catt_process.pid, signal.SIGINT)
self.catt_process.wait()
except:
pass
self.catt_process = None
def populateForm(self, title): #title is the primary key
listArray = queries("""SELECT title, status, style, duration, description,
location, project, variation_another_song, timestamp from songs WHERE title = ?""", (title,))
print(listArray)
if len(listArray) != 0:
title = listArray[0][0]
status = listArray[0][1]
styles = []
styleArray = listArray[0][2]
if styleArray != None:
if "," in styleArray:
styles = styleArray.split(",")
else:
styles.append(styleArray)
duration = listArray[0][3]
description = listArray[0][4]
location = listArray[0][5]
project = listArray[0][6]
variation_another_song = listArray[0][7]
timestamp = listArray[0][8]
else:
title = None
status = None
styles = None
duration = None
description = None
location = None
project = None
variation_another_song = None
timestamp = None
if title != None: self.titleEdit.setText(title)
self.statusBox.addItems(["Select...", "Demo", "WIP", "Idea", "Unfinished song", "EQ", "Master", "Finished"])
if status != None: self.statusBox.setCurrentText(status)
if timestamp != None: self.dateEdit.setDateTime(datetime.strptime(timestamp, '%d/%m/%Y %H:%M'))
else: self.dateEdit.setDateTime(datetime.now())#default
styleArray = queries("select style from songs where style is not null")
"""
print(styleArray)
if styleArray != None:
styleArray = styleArray[0][0]
if "," in styleArray:
styles = styleArray.split(",")
else:
styles.append(styleArray)"""
stylesArray = []
query = queries("select style from songs where style is not null")
if len(query) != 0:
for style in query:
stylesMiniArray = style[0].split(",")
stylesMiniArray = list(filter(None, stylesMiniArray))
for item in stylesMiniArray:
if item not in stylesArray:
if item != '':
stylesArray.append(item)
self.x = 0
self.y = 0
if len(stylesArray) != 0:
for style in stylesArray:
print("style", style)
checkBox = QCheckBox(style)
self.styleLayout.addWidget(checkBox, self.x, self.y)
self.checkBoxPositionAsignment()
self.addStyle()
if styles!= None:
if len(styles) != 0:
for style in styles:
for checkbox in self.styleGroupBox.children():
if isinstance(checkbox, QCheckBox):
if checkbox.text() == style:
checkbox.setChecked(True)
if duration != None:
time = QTime(0,0,0)
self.durationLine.setTime(time.addSecs(duration))
projectsArray = ["Select..."]
projectsArrayQuery = queries("SELECT project from songs")
if len(projectsArrayQuery) != 0:
for project in projectsArrayQuery[0]:
if project not in projectsArray:
projectsArray.append(project)
if project != None: self.projectComboBox.setCurrentText(project)
if variation_another_song != None: self.variationLine.setText(variation_another_song)
if description != None: self.descriptionTextEdit.setText(description)
available = False
if location != None:
self.locationLine.setText(location)
if len(self.locationLine.text()) != 0:
try:
self.playlist = QMediaPlaylist()
self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(location)))
self.mediaPlayer.setPlaylist(self.playlist)
except:
pass
available = True#I know this is stupid but just in case
self.slider.setVisible(available)
self.playButton.setVisible(available)
self.stopButton.setVisible(available)
class Board(QFrame):
"""
Everything to handle the game: Drawing pieces and the board, Handling the mouse and the game logic
"""
msg2Statusbar = pyqtSignal(str)
# todo set the board with and height in square
boardWidth = 8
boardHeight = 8
Speed = 300
def __init__(self, parent):
super().__init__(parent)
self.init()
def init(self):
"""
Initialise all values
:return:
"""
self.boardArray = [[0, 3, 0, 3, 0, 3, 0, 3],
[3, 0, 3, 0, 3, 0, 3, 0],
[0, 3, 0, 3, 0, 3, 0, 3],
[1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1],
[2, 0, 2, 0, 2, 0, 2, 0],
[0, 2, 0, 2, 0, 2, 0, 2],
[2, 0, 2, 0, 2, 0, 2, 0]]
# Timer initialization
self.timer = QTimer()
self.time = QTime(0, 0, 0)
self.timer.timeout.connect(self.timerEventGame)
self.timerPlayer = QTimer()
self.timePlayer = QTime(0, 1, 0)
self.timer.timeout.connect(self.timerEventPlayer)
self.isWaitingAfterLine = False
self.numLinesRemoved = 0
# image de la piece de base m'voyez
self.image = QImage(WHITE_PIECE)
# self.setFocusPolicy(Qt.StrongFocus)
self.isStarted = False
self.isPaused = False
self.reset_game()
self.selected_piece = [-1, -1]
self.player_turn = 1
# nombre de piece = [nb de piece joueur 1, nb de piece jour 2]
self.playersRemaining = [12, 12]
# nombre de jump = [nb de jump joueur 1, nb de jump jour 2]
self.playersJumps = [0, 0]
self.scoreBoard = None
self.status = FPLAYER
# si le temps du joueur a timeout
self.timePassed = False
self.startTime = 0
self.interval = 0
# pour changer l'affichage si on jou contre une AI
self.isAI = False
self.winner = -1
self.aiDifficulties = 2
def timerEventGame(self):
"""
This function allows to update the game timer and update the scoreBoard.
:return: Nothing
"""
# Update the game timer
self.time = self.time.addSecs(1)
# Update de UI of the scoreBoard
self.scoreBoard.updateUI()
def initPlayerTimer(self):
"""
Init the player timer when the player begin his turn.
:return: Nothing
"""
self.timerPlayer = QTimer()
self.timePlayer = QTime(0, 1, 0)
def startTimerInter(self, interval):
"""
Start the player timer with an given interval.
:param interval: The interval from which time must resume
:return: Nothing
"""
self.timerPlayer.start(interval)
def startTimerPlayer(self):
""""
Function to start a player timer with an interval of 1000.
"""
self.interval = 1000
self.startTime = time.time()
self.timerPlayer.start(1000)
def timerEventPlayer(self):
"""
This function allows to update the timer of the player one.
:return: Nothing
"""
self.timePlayer = self.timePlayer.addSecs(-1)
if self.timerPlayer.isActive():
if self.timePlayer.minute() * 60 + self.timePlayer.second() < 1:
self.timePassed = True
self.timerPassedEndGame()
self.scoreBoard.updateUI()
def setScoreBoard(self, scoreBoard):
"""
This function allows to get the scoreBoard class to use it later in the code.
:param scoreBoard: The class scoreBoard
:return: Nothing
"""
self.scoreBoard = scoreBoard
def print_board_array(self):
"""
Prints the boardArray in an attractive way
:return: Nothing
"""
print("boardArray:")
print('\n'.join(['\t'.join([str(cell) for cell in row]) for row in self.boardArray]))
def mouse_pos_to_col_row(self, event):
"""
Convert the mouse click event to a row and column.
:param event: The click event
:return: The click's position with the following format: [x, y] (Example: [3, 4])
"""
return [int(event.x() / self.square_width()), int(event.y() / self.square_height())]
def square_width(self):
"""
This function allows to return the width of one square in the board.
:return: The width of one square in the board.
"""
return self.contentsRect().width() / Board.boardWidth
def square_height(self):
"""
This function allows to return the height of one square in the board.
:return: The height of one square in the board
"""
return self.contentsRect().height() / Board.boardHeight
def start(self):
"""starts game"""
if self.isPaused:
return
self.isStarted = True
self.isWaitingAfterLine = False
self.numLinesRemoved = 0
self.reset_game()
self.timer.start(1000)
self.startTimerPlayer()
# self.timerPlayer.start(1000)
def pause(self):
"""pauses game"""
if not self.isStarted:
return
self.isPaused = not self.isPaused
if self.isPaused:
self.timerPlayer.stop()
self.timer.stop()
self.status = "Game paused"
elapsedTime = self.startTime - time.time()
self.startTime -= elapsedTime
self.interval -= int(elapsedTime * 1000)
else:
self.timer.start()
self.startTimerInter(self.interval)
if self.player_turn == 1:
self.status = FPLAYER
elif self.isAI:
self.status = AIPLAYER
else:
self.status = SPLAYER
self.scoreBoard.updateUI()
self.update()
def paintEvent(self, event):
"""paints the board and the pieces of the game"""
painter = QPainter(self)
self.draw_board_squares(painter)
self.draw_pieces(painter)
def new_place(self, turn, row, col, change):
"""
Change the piece place
:param turn:
:param row:
:param col:
:param change:
:return:
"""
self.boardArray[row][col] = self.boardArray[self.selected_piece[1]][self.selected_piece[0]]
if (row == 0 and self.boardArray[row][col] == 2) or (row == 7 and self.boardArray[row][col] == 3):
self.boardArray[row][col] += 2
self.boardArray[self.selected_piece[1]][self.selected_piece[0]] = 1
if change == 1:
self.selected_piece = [-1, -1]
else:
self.selected_piece = [col, row]
self.player_turn = turn
self.scoreBoard.updateUI()
def first_player_take(self, row, col):
"""
Take a piece for the first player
:param row:
:param col:
:return:
"""
p = 2
change = 1
b = 0
r = self.selected_piece[1]
c = self.selected_piece[0]
if self.boardArray[r][c] == 2 and r > 1 and c > 1 and self.boardArray[r - 2][c - 2] == 1 and \
self.boardArray[r - 1][c - 1] == 3:
b = 1
elif self.boardArray[r][c] == 2 and r > 1 and c < 6 and self.boardArray[r - 2][c + 2] == 1 and \
self.boardArray[r - 1][c + 1] == 3:
b = 1
if b == 0 and self.player_turn == 1 and self.boardArray[row][col] == 1 and row == self.selected_piece[1] - 1 \
and (col == self.selected_piece[0] + 1 or col == self.selected_piece[0] - 1):
self.new_place(2, row, col, change)
elif self.player_turn == 1 and self.boardArray[row][col] == 1 and row == self.selected_piece[1] - 2 \
and col == self.selected_piece[0] + 2 and self.boardArray[row + 1][col - 1] == 3:
self.boardArray[row + 1][col - 1] = 1
self.playersRemaining[1] -= 1
if self.playersRemaining[1] == 0:
self.timePassed = True
self.player_turn = 2
self.timerPassedEndGame()
self.playersJumps[0] += 1
if row > 1 and col > 1 and self.boardArray[row - 2][col - 2] == 1 and self.boardArray[row - 1][col - 1] == 3:
p = 1
change = 0
elif row > 1 and col < 6 and self.boardArray[row - 2][col + 2] == 1 and self.boardArray[row - 1][col + 1] == 3:
p = 1
change = 0
self.new_place(p, row, col, change)
elif self.player_turn == 1 and self.boardArray[row][col] == 1 and row == self.selected_piece[1] - 2 \
and col == self.selected_piece[0] - 2 and self.boardArray[row + 1][col + 1] == 3:
self.boardArray[row + 1][col + 1] = 1
self.playersRemaining[1] -= 1
if self.playersRemaining[1] == 0:
self.timePassed = True
self.player_turn = 2
self.timerPassedEndGame()
self.playersJumps[0] += 1
if row > 1 and col > 1 and self.boardArray[row - 2][col - 2] == 1 and self.boardArray[row - 1][col - 1] == 3:
p = 1
change = 0
elif row > 1 and col < 6 and self.boardArray[row - 2][col + 2] == 1 and self.boardArray[row - 1][col + 1] == 3:
p = 1
change = 0
self.new_place(p, row, col, change)
def second_player_take(self, row, col):
"""
Take a piece for the second player
:param row:
:param col:
:return:
"""
p = 1
change = 1
b = 0
r = self.selected_piece[1]
c = self.selected_piece[0]
if self.boardArray[r][c] == 3 and r < 6 and c > 1 and self.boardArray[r + 2][c - 2] == 1 and \
self.boardArray[r + 1][c - 1] == 2:
b = 1
elif self.boardArray[r][c] == 3 and r < 6 and c < 6 and self.boardArray[r + 2][c + 2] == 1 and \
self.boardArray[r + 1][c + 1] == 2:
b = 1
if b == 0 and self.player_turn == 2 and self.boardArray[row][col] == 1 and row == self.selected_piece[1] + 1 \
and (col == self.selected_piece[0] + 1 or col == self.selected_piece[0] - 1):
self.new_place(p, row, col, change)
elif self.player_turn == 2 and self.boardArray[row][col] == 1 and row == self.selected_piece[1] + 2 \
and col == self.selected_piece[0] + 2 and self.boardArray[row - 1][col - 1] == 2:
self.boardArray[row - 1][col - 1] = 1
self.playersRemaining[0] -= 1
if self.playersRemaining[0] == 0:
self.timePassed = True
self.player_turn = 1
self.timerPassedEndGame()
self.playersJumps[1] += 1
if row < 6 and col > 1 and self.boardArray[row + 2][col - 2] == 1 and self.boardArray[row + 1][col - 1] == 2:
p = 2
change = 0
elif row < 6 and col < 6 and self.boardArray[row + 2][col + 2] == 1 and self.boardArray[row + 1][col + 1] == 2:
p = 2
change = 0
self.new_place(p, row, col, change)
elif self.player_turn == 2 and self.boardArray[row][col] == 1 and row == self.selected_piece[1] + 2 \
and col == self.selected_piece[0] - 2 and self.boardArray[row - 1][col + 1] == 2:
self.boardArray[row - 1][col + 1] = 1
self.playersRemaining[0] -= 1
if self.playersRemaining[0] == 0:
self.timePassed = True
self.player_turn = 1
self.timerPassedEndGame()
self.playersJumps[1] += 1
if row < 6 and col > 1 and self.boardArray[row + 2][col - 2] == 1 and self.boardArray[row + 1][col - 1] == 2:
p = 2
change = 0
elif row < 6 and col < 6 and self.boardArray[row + 2][col + 2] == 1 and self.boardArray[row + 1][col + 1] == 2:
p = 2
change = 0
self.new_place(p, row, col, change)
def mousePressEvent(self, event):
"""
Get the pos clicked and call the game logic
:param event:
:return:
"""
if not self.isPaused:
clicked = self.mouse_pos_to_col_row(event)
if clicked:
self.logicGame(clicked)
def AI(self):
"""
Creates the AI class with the array board.
Then, it get the positions choosed by the AI.
Finally it call the logic Game to move the piece.
:return: Nothing
"""
self.selected_piece = [-1, -1]
self.ai = AI(self.boardArray)
positions = self.ai.MinMaxDecision(self.aiDifficulties)
self.logicGame([positions[0][1], positions[0][0]])
self.logicGame([positions[1][1], positions[1][0]])
def timerPassedEndGame(self):
"""
When a player take a lot of time to play (1 minutes)
:return: -1 (value for the end of the game)
"""
self.status = ENDGAME
self.timerPlayer.stop()
self.timer.stop()
if self.player_turn == 1:
if not self.isAI:
self.winner = 2
else:
self.winner = 3
else:
self.winner = 1
# self.scoreBoard.updateUI()
# self.init()
return -1
def logicGame(self, positions):
"""
Game logic to manage pieces moves
:param positions:
:return:
"""
row = positions[1]
col = positions[0]
if self.timePassed:
return self.timerPassedEndGame()
if self.player_turn == 1:
self.status = FPLAYER
elif self.isAI:
self.status = AIPLAYER
else:
self.status = SPLAYER
if self.selected_piece == [-1, -1]:
if self.player_turn == 1:
b = 0
for r in range(0, len(self.boardArray)):
for c in range(0, len(self.boardArray[0])):
if self.boardArray[r][c] == 2 and r > 1 and c > 1 and self.boardArray[r - 2][c - 2] == 1 and self.boardArray[r - 1][c - 1] == 3:
b = 1
elif self.boardArray[r][c] == 2 and r > 1 and c < 6 and self.boardArray[r - 2][c + 2] == 1 and self.boardArray[r - 1][c + 1] == 3:
b = 1
if self.boardArray[row][col] == self.player_turn + 1:
if (b == 0 and row > 0 and col > 0 and self.boardArray[row - 1][col - 1] == 1) \
or (b == 0 and row > 0 and col < 7 and self.boardArray[row - 1][col + 1] == 1):
self.selected_piece = positions
elif row > 1 and col > 1 and self.boardArray[row - 2][col - 2] == 1 and self.boardArray[row - 1][col - 1] == 3:
self.selected_piece = positions
elif row > 1 and col < 6 and self.boardArray[row - 2][col + 2] == 1 and self.boardArray[row - 1][col + 1] == 3:
self.selected_piece = positions
elif self.player_turn == 2:
b = 0
for r in range(0, len(self.boardArray)):
for c in range(0, len(self.boardArray[0])):
if self.boardArray[r][c] == 3 and r < 6 and c > 1 and self.boardArray[r + 2][c - 2] == 1 and self.boardArray[r + 1][c - 1] == 2:
b = 1
elif self.boardArray[r][c] == 3 and r < 6 and c < 6 and self.boardArray[r + 2][c + 2] == 1 and self.boardArray[r + 1][c + 1] == 2:
b = 1
if self.boardArray[row][col] == self.player_turn + 1:
if (b == 0 and row < 7 and col > 0 and self.boardArray[row + 1][col - 1] == 1) \
or (b == 0 and row < 7 and col < 7 and self.boardArray[row + 1][col + 1] == 1):
self.selected_piece = positions
elif row < 6 and col > 1 and self.boardArray[row + 2][col - 2] == 1 and self.boardArray[row + 1][col - 1] == 2:
self.selected_piece = positions
elif row < 6 and col < 6 and self.boardArray[row + 2][col + 2] == 1 and self.boardArray[row + 1][col + 1] == 2:
self.selected_piece = positions
else:
if self.selected_piece == positions:
self.selected_piece = [-1,-1]
return
self.first_player_take(row, col)
self.second_player_take(row, col)
if self.player_turn == 1:
self.status = FPLAYER
else:
self.status = SPLAYER
self.initPlayerTimer()
self.startTimerPlayer()
if self.player_turn == 2 and self.isAI:
self.AI()
def keyPressEvent(self, event):
"""processes key press events if you would like to do any"""
if not self.isStarted or self.curPiece.shape() == Piece.NoPiece:
super(Board, self).keyPressEvent(event)
return
key = event.key()
if key == Qt.Key_P:
self.pause()
return
if self.isPaused:
return
elif key == Qt.Key_Left:
self.try_move(self.curPiece, self.curX - 1, self.curY)
elif key == Qt.Key_Right:
self.try_move(self.curPiece, self.curX + 1, self.curY)
elif key == Qt.Key_Down:
self.try_move(self.curPiece.rotateRight(), self.curX, self.curY)
elif key == Qt.Key_Up:
self.try_move(self.curPiece.rotateLeft(), self.curX, self.curY)
elif key == Qt.Key_Space:
self.dropDown()
elif key == Qt.Key_D:
self.oneLineDown()
else:
super(Board, self).keyPressEvent(event)
def timerEvent(self, event):
"""handles timer event"""
#todo adapter this code to handle your timers
if event.timerId() == self.timer.timerId():
pass
else:
super(Board, self).timerEvent(event)
def reset_game(self):
"""clears pieces from the board"""
# 2d int/Piece array to story the state of the game
# 2 pion blanc, 3 pion noir
self.boardArray = [[0, 3, 0, 3, 0, 3, 0, 3],
[3, 0, 3, 0, 3, 0, 3, 0],
[0, 3, 0, 3, 0, 3, 0, 3],
[1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1],
[2, 0, 2, 0, 2, 0, 2, 0],
[0, 2, 0, 2, 0, 2, 0, 2],
[2, 0, 2, 0, 2, 0, 2, 0]]
self.selected_piece = [-1, -1]
# self.print_board_array()
def try_move(self, new_x, new_y):
"""tries to move a piece"""
def draw_board_squares(self, painter):
"""
This function allows to draw all the square on the board.
:param painter: The painter
:return: Nothing
"""
# todo set the default colour of the brush
images = [QImage(WHITE_SQUARE), QImage(BLACK_SQUARE)]
idx = 0
for row in range(0, Board.boardHeight):
for col in range(0, Board.boardWidth):
#painter.save()
# Todo set this value equal the transformation you would like in the column direction (x)
colTransformation = col * self.square_width()
# Todo set this value equal the transformation you would like in the column direction (y)
row_transformation = row * self.square_height()
final_image = images[idx].scaled(self.square_width(), self.square_height())
painter.drawImage(colTransformation, row_transformation, final_image)
#painter.restore()
idx = 1 if idx == 0 else 0
idx = 1 if idx == 0 else 0
def color_brush_white(self, row, col, i):
"""
Set the brush color for white pieces
:param row:
:param col:
:param i:
:return:
"""
brush_color = Qt.black
if self.player_turn == 1 and self.selected_piece[1] == row and self.selected_piece[0] == col:
brush_color = QColor.fromRgb(100, 255, 100)
elif self.player_turn == 1 and self.selected_piece == [-1, -1]:
if i > 0 and row > 0 and col > 0 and self.boardArray[row - 1][col - 1] == 1:
brush_color = Qt.white
elif i > 0 and row > 0 and col < 7 and self.boardArray[row - 1][col + 1] == 1:
brush_color = Qt.white
elif row > 1 and col > 1 and self.boardArray[row - 2][col - 2] == 1 and self.boardArray[row - 1][col - 1] == 3:
brush_color = Qt.white
elif row > 1 and col < 6 and self.boardArray[row - 2][col + 2] == 1 and self.boardArray[row - 1][col + 1] == 3:
brush_color = Qt.white
return brush_color
def color_brush_black(self, row, col, i):
"""
Set the brush color for black pieces
:param row:
:param col:
:param i:
:return:
"""
brush_color = Qt.black
if self.player_turn == 2 and self.selected_piece[1] == row and self.selected_piece[0] == col:
brush_color = QColor.fromRgb(100, 100, 255)
elif self.player_turn == 2 and self.selected_piece == [-1, -1]:
if i > 0 and row < 7 and col > 0 and self.boardArray[row + 1][col - 1] == 1:
brush_color = QColor.fromRgb(255, 0, 255)
elif i > 0 and row < 7 and col < 7 and self.boardArray[row + 1][col + 1] == 1:
brush_color = QColor.fromRgb(255, 0, 255)
elif row < 6 and col > 1 and self.boardArray[row + 2][col - 2] == 1 and self.boardArray[row + 1][col - 1] == 2:
brush_color = QColor.fromRgb(255, 0, 255)
elif row < 6 and col < 6 and self.boardArray[row + 2][col + 2] == 1 and self.boardArray[row + 1][col + 1] == 2:
brush_color = QColor.fromRgb(255, 0, 255)
return brush_color
def draw_pieces(self, painter):
"""draw the prices on the board"""
brush_color = QColor.fromRgb(200, 200, 200)
images = [QImage(WHITE_PIECE), QImage(BLACK_PIECE), QImage(WHITE_KING), QImage(BLACK_KING), QImage(BLACK_SQUARE)]
idx = 0
i = 0
y = 1
while i < 2:
for row in range(0, len(self.boardArray)):
for col in range(0, len(self.boardArray[0])):
#painter.save()
col_transformation = col * self.square_width()
row_transformation = row * self.square_height()
## Todo victoire quand bloquer
if self.boardArray[row][col] == 2:
brush_color = self.color_brush_white(row, col, i)
idx = 0
elif self.boardArray[row][col] == 1:
brush_color = Qt.black
idx = 4
elif self.boardArray[row][col] == 3:
brush_color = self.color_brush_black(row, col, i)
idx = 1
elif self.boardArray[row][col] == 4:
brush_color = self.color_brush_white(row, col, i)
idx = 2
elif self.boardArray[row][col] == 5:
brush_color = self.color_brush_black(row, col, i)
idx = 3
elif self.boardArray[row][col] == 6:
brush_color = QColor.fromRgb(128, 128, 128)
if self.boardArray[row][col] != 0:
painter.setPen(brush_color)
if brush_color == Qt.white or brush_color == QColor.fromRgb(255, 0, 255):
y = 2
# Todo draw some the pieces as eclipses
radius_width = (self.square_width() / 10 * 8) / 2
radius_height = (self.square_height() / 10 * 8) / 2
center = QPoint(col_transformation + (self.square_width() / 2),
row_transformation + (self.square_height() / 2))
if idx != 4:
painter.drawEllipse(center, radius_width, radius_height)
self.image = images[idx].scaled(radius_width * 2, radius_height * 2)
painter.drawImage(center.x() - radius_width, center.y() - radius_height, self.image)
#painter.restore()
self.update()
i += y
class TimerWindow(QWidget):
#Button control functions
def handleStartBtn(self):
global isStarted
isStarted = True
self.statusInput.setText("Timer Started!")
self.statusInput.setStyleSheet('color: grey')
def handleStopBtn(self):
global isStarted
if isStarted:
isStarted = False
self.statusInput.setText("Reset Timer?")
self.statusInput.setStyleSheet('color: blue')
def handleResetBtn(self):
global isStarted
global elapseHours
isStarted = False
elapseHours = 0
self.stopwatchTime = QTime(0, 0, 0, 0)
self.curElapse.setText("00:00:00:000 ms")
self.updateTimer()
def handleCloseBtn(self):
print("Close Button Pressed!")
self.hide()
def formatTime(self):
#Find current time
timeNow = QTime.currentTime()
fullTime = timeNow.toString("hh:mm:ss:zzz 'ms'")
return fullTime
def formatElapse(self):
global elapseHours
if self.stopwatchTime.hour() == 1:
elapseHours += 1
self.stopwatchTime = self.stopwatchTime.addSecs(-3600)
if elapseHours < 10:
elapseHoursS = "0" + str(elapseHours)
else:
elapseHoursS = str(elapseHours)
fullElapseS = elapseHoursS + ":" + self.stopwatchTime.toString(
"mm:ss:zzz 'ms'")
return fullElapseS
def deductTimer(self):
global totalMSecRemain
totalMSecRemain -= 87
def formatTimer(self):
global totalMSecRemain
global isInfoShown
#Return zeros if miliseconds remaining are negative
if totalMSecRemain <= 0:
if not isInfoShown:
showInfo("Time is Up!")
isInfoShown = True
return "00:00:00:000 ms"
#Calculate timer values
totalHours = int(totalMSecRemain / 3600000)
totalMin = int((totalMSecRemain % 3600000) / 60000)
totalSec = int(((totalMSecRemain % 3600000) % 60000) / 1000)
totalMilSec = int(((totalMSecRemain % 3600000) % 60000) % 1000)
#Update timer label
if totalHours == 0:
totalHoursS = "00"
elif totalHours < 10:
totalHoursS = "0" + str(totalHours)
else:
totalHoursS = str(totalHours)
if totalMin == 0:
totalMinS = "00"
elif totalMin < 10:
totalMinS = "0" + str(totalMin)
else:
totalMinS = str(totalMin)
if totalSec == 0:
totalSecS = "00"
elif totalSec < 10:
totalSecS = "0" + str(totalSec)
else:
totalSecS = str(totalSec)
if totalMilSec == 0:
totalMilSecS = "000"
elif totalMilSec < 10:
totalMilSecS = "00" + str(totalMilSec)
elif totalMilSec < 100:
totalMilSecS = "0" + str(totalMilSec)
else:
totalMilSecS = str(totalMilSec)
fullTimerS = totalHoursS + ":" + totalMinS + ":" + totalSecS + ":" + totalMilSecS + " ms"
return fullTimerS
def updateTime(self):
#Update of cur time clock
self.curTime.setText(self.formatTime())
#Update next two clocks if started
if isStarted == True:
#Update of elapsed time
self.stopwatchTime = self.stopwatchTime.addMSecs(87)
self.curElapse.setText(self.formatElapse())
#Update of timer clock
self.deductTimer()
self.curTimer.setText(self.formatTimer())
def updateTimer(self):
if isStarted:
return
global totalMSecRemain
global isInfoShown
inputPresent = False
isAccepted = False
#Value validation
try:
if self.hourInputFeild.text() != "":
hourInputNum = int(float(self.hourInputFeild.text()))
inputPresent = True
isAccepted = True
else:
hourInputNum = 0
if self.minInputFeild.text() != "":
minInputNum = int(float(self.minInputFeild.text()))
inputPresent = True
isAccepted = True
else:
minInputNum = 0
if self.secInputFeild.text() != "":
secInputNum = int(float(self.secInputFeild.text()))
inputPresent = True
isAccepted = True
else:
secInputNum = 0
self.statusInput.setText("Input Accepted!")
self.statusInput.setStyleSheet('color: green')
except ValueError:
isAccepted = False
inputPresent = True
self.statusInput.setText("Input Declined")
self.statusInput.setStyleSheet('color: red')
if (inputPresent == False) or ((hourInputNum == 0) and
(minInputNum == 0) and
(secInputNum == 0)):
totalMSecRemain = 1
isAccepted = False
self.curTimer.setText("00:00:00:000 ms")
self.statusInput.setText("Awaiting Input!")
self.statusInput.setStyleSheet('color: orange')
#Update timer variable if value accepted
if (isAccepted == True):
#Calculate timer values
isInfoShown = False
totalMSecRemain = (hourInputNum * 3600000) + (
minInputNum * 60000) + (secInputNum * 1000)
fullTimerS = self.formatTimer()
self.curTimer.setText(fullTimerS)
def initWindow(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.show()
def horLine(self):
hLine = QFrame()
hLine.setFrameShape(QFrame.HLine)
hLine.setFrameShadow(QFrame.Sunken)
return hLine
def __init__(self, screenW, screenH):
super().__init__()
self.title = "Simple Timer"
self.width = 640
self.height = 480
self.left = (screenW / 2) - (self.width / 2)
self.top = (screenH / 2) - (self.height / 2)
#Create button horizontal layout
btnBox = QHBoxLayout()
btnBox.addStretch(.5)
#Create button instaces
self.startBtn = QPushButton('Start', self)
self.startBtn.clicked.connect(self.handleStartBtn)
self.stopBtn = QPushButton('Stop', self)
self.stopBtn.clicked.connect(self.handleStopBtn)
self.resetBtn = QPushButton('Reset', self)
self.resetBtn.clicked.connect(self.handleResetBtn)
self.closeBtn = QPushButton('Close', self)
self.closeBtn.clicked.connect(self.handleCloseBtn)
#Add buttons to layout
btnBox.addWidget(self.startBtn)
btnBox.addWidget(self.stopBtn)
btnBox.addWidget(self.resetBtn)
btnBox.addWidget(self.closeBtn)
btnBox.addStretch(.5)
#Create Update Calls for All Clocks
self.curTimeTimer = QTimer(self)
self.curTimeTimer.timeout.connect(self.updateTime)
self.curTimeTimer.start(87)
#Create Three Info Clocks
timeFont = QFont("Ariel", 40)
#Set the initial current time at start
curTimeBox = QHBoxLayout()
curTimeBox.addStretch(.5)
self.curTime = QLabel(self.formatTime(), self)
self.curTime.setFont(timeFont)
curTimeBox.addWidget(self.curTime)
curTimeBox.addStretch(.5)
#Set the initial timer time at start
curTimerBox = QHBoxLayout()
curTimerBox.addStretch(.5)
self.curTimer = QLabel("00:00:00:000 ms", self)
self.curTimer.setFont(timeFont)
curTimerBox.addWidget(self.curTimer)
curTimerBox.addStretch(.5)
#Set the initial elapsed time at start
self.stopwatchTime = QTime(0, 0, 0, 0)
curElapseBox = QHBoxLayout()
curElapseBox.addStretch(.5)
self.curElapse = QLabel("00:00:00:000 ms", self)
self.curElapse.setFont(timeFont)
curElapseBox.addWidget(self.curElapse)
curElapseBox.addStretch(.5)
#Create timer input feilds
inputBox = QHBoxLayout()
self.introInput = QLabel('Set timer to -', self)
self.hourInput = QLabel(' Hours:', self)
self.hourInputFeild = QLineEdit()
self.minInput = QLabel(' Minutes:', self)
self.minInputFeild = QLineEdit()
self.secInput = QLabel(' Seconds:', self)
self.secInputFeild = QLineEdit()
self.statusInput = QLabel('Awaiting Input!', self)
self.statusInput.setStyleSheet('color: orange')
inputBox.addStretch(.2)
inputBox.addWidget(self.introInput)
inputBox.addStretch(.3)
inputBox.addWidget(self.hourInput)
inputBox.addWidget(self.hourInputFeild)
inputBox.addWidget(self.minInput)
inputBox.addWidget(self.minInputFeild)
inputBox.addWidget(self.secInput)
inputBox.addWidget(self.secInputFeild)
inputBox.addStretch(.3)
inputBox.addWidget(self.statusInput)
inputBox.addStretch(.2)
#Connect input signals to the apropriate function
self.hourInputFeild.textChanged.connect(self.updateTimer)
self.minInputFeild.textChanged.connect(self.updateTimer)
self.secInputFeild.textChanged.connect(self.updateTimer)
#Create all static labels
titleFont = QFont("Courier", 20)
self.curTimeTitle = QLabel('Current Time:', self)
self.curTimeTitle.setFont(titleFont)
self.curTimerTitle = QLabel('Time Remaining:', self)
self.curTimerTitle.setFont(titleFont)
self.curElapseTitle = QLabel('Elapsed Time:', self)
self.curElapseTitle.setFont(titleFont)
#Create and populate root layout
rootBox = QVBoxLayout()
rootBox.addWidget(self.curTimeTitle)
rootBox.addLayout(curTimeBox)
rootBox.addStretch(.165)
rootBox.addWidget(self.horLine())
rootBox.addStretch(.165)
rootBox.addWidget(self.curTimerTitle)
rootBox.addLayout(curTimerBox)
rootBox.addStretch(.165)
rootBox.addWidget(self.horLine())
rootBox.addStretch(.165)
rootBox.addWidget(self.curElapseTitle)
rootBox.addLayout(curElapseBox)
rootBox.addStretch(.165)
rootBox.addWidget(self.horLine())
rootBox.addStretch(.165)
rootBox.addLayout(inputBox)
rootBox.addLayout(btnBox)
self.setLayout(rootBox)
self.initWindow()
class TimeFrame(BaseFrame):
time_hacked = pyqtSignal()
def __init__(self, is_mission, parent=None):
super().__init__(parent)
# Setup frame
self.label.setText("Time:")
zulu_label = QLabel("ZULU")
zulu_label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.time_edit = QTimeEdit()
self.time_edit.setDisplayFormat("HH:mm:ss")
self.hack_btn = QPushButton("Hack")
self.hack_btn.setAutoDefault(False)
if is_mission:
self.hack_btn.setStyleSheet("background-color: red; color: white;")
else:
self.hack_btn.setStyleSheet(
"background-color: gray; color: white;")
self.sys_time_btn = QPushButton("Use System Time")
self.sys_time_btn.setAutoDefault(False)
if not is_mission:
self.time_edit.setEnabled(False)
self.hack_btn.setEnabled(False)
self.sys_time_btn.setEnabled(False)
self.layout.addWidget(self.label)
self.layout.addWidget(self.time_edit)
self.layout.addWidget(zulu_label)
self.layout.addWidget(self.hack_btn)
self.layout.addWidget(self.sys_time_btn)
self.setLayout(self.layout)
# Setup behavior
self.time = QTime()
self.hack_timer = QTimer()
self.hack_timer.setTimerType(Qt.VeryCoarseTimer)
self.hack_timer.setInterval(1000)
self.hack_timer.timeout.connect(self.inc_time)
self.hack_btn.clicked.connect(self.hack_time)
self.sys_time_btn.clicked.connect(self.set_sys_time)
@pyqtSlot()
def hack_time(self, sys_time=None):
if not self.hack_timer.isActive():
self.time = self.time_edit.time() if not sys_time else sys_time
self.hack_timer.start()
self.time_edit.setTime(self.time)
self.hack_btn.setStyleSheet(
"background-color: green; color: white;")
self.hack_btn.setText("Hacked!")
self.time_edit.setEnabled(False)
self.sys_time_btn.setEnabled(False)
else:
self.hack_btn.setStyleSheet("background-color: red; color: white;")
self.hack_btn.setText("Hack")
self.hack_timer.stop()
self.time_edit.setEnabled(True)
self.sys_time_btn.setEnabled(True)
self.time_hacked.emit()
@pyqtSlot()
def set_sys_time(self):
self.hack_time(QTime().currentTime())
@pyqtSlot()
def inc_time(self):
self.time = self.time.addSecs(1)
self.time_edit.setTime(self.time)
class ArithmeticWidget(QWidget):
stop_signal = pyqtSignal()
def __init__(self, operand_range: tuple, operators: tuple, parent=None):
super(ArithmeticWidget, self).__init__(parent)
self.operator_dict = {
'+': self.add,
'-': self.sub,
'*': self.mul,
'//': self.floordiv
}
self.operand_range = operand_range
self.operators = operators
self.operand_left = None
self.operand_right = None
self.correct_answer = None
self.counter = 0
main_box = QVBoxLayout()
# backend timer
self.time = QTime(0, 0, 0)
self.timer = QTimer()
self.timer.start(1000)
self.timer.timeout.connect(self.change_time)
# counter examples and timer
self.counter_label = QLabel(str(self.counter))
self.counter_label.setAlignment(Qt.AlignLeft)
self.time_label = QLabel('0:00:00')
self.time_label.setAlignment(Qt.AlignRight)
h_box = QHBoxLayout()
h_box.setContentsMargins(50, 20, 50, 0)
h_box.addWidget(self.counter_label)
h_box.addWidget(self.time_label)
main_box.addLayout(h_box)
# labels of nums and sign
self.num_1_label = QLabel()
self.num_1_label.setAlignment(Qt.AlignRight)
self.num_2_label = QLabel()
self.num_2_label.setAlignment(Qt.AlignLeft)
self.sign_label = QLabel()
self.sign_label.setFixedWidth(20)
self.sign_label.setAlignment(Qt.AlignHCenter)
h_box = QHBoxLayout()
h_box.setContentsMargins(80, 0, 80, 0)
h_box.addWidget(self.num_1_label)
h_box.addWidget(self.sign_label)
h_box.addWidget(self.num_2_label)
main_box.addLayout(h_box)
# answer field
self.answer_field = QLineEdit()
self.answer_field.returnPressed.connect(self.check_answer)
self.answer_field.setAlignment(Qt.AlignCenter)
self.answer_field.setValidator(QIntValidator())
h_box = QHBoxLayout()
h_box.setContentsMargins(80, 0, 80, 0)
h_box.addWidget(self.answer_field)
main_box.addLayout(h_box)
# buttons
self.confirm_btn = MyButton(btn_text='Enter',
bg_color='rgb(138, 226, 52)',
text_color='black',
delay=False)
self.confirm_btn.clicked.connect(self.check_answer)
h_box = QHBoxLayout()
h_box.addWidget(self.confirm_btn)
main_box.addLayout(h_box)
self.skip_btn = MyButton(btn_text='Skip',
bg_color='rgb(252, 233, 79)',
text_color='black',
delay=False)
self.skip_btn.clicked.connect(self.show_next_example)
self.stop_btn = MyButton(btn_text='Stop',
bg_color='red',
text_color='white')
self.stop_btn.clicked.connect(self.stop_session)
h_box = QHBoxLayout()
h_box.addWidget(self.skip_btn)
h_box.addWidget(self.stop_btn)
main_box.addLayout(h_box)
self.setLayout(main_box)
self.setAttribute(Qt.WA_DeleteOnClose)
self.show_next_example()
def change_time(self):
self.time = self.time.addSecs(1)
text = self.time.toString('h:mm:ss')
self.time_label.setText(text)
def show_next_example(self):
operand_left = random.randint(*self.operand_range)
operand_right = random.randint(*self.operand_range)
operator = random.choice(self.operators)
func = self.operator_dict[operator]
func(operand_left, operand_right)
self.num_1_label.setText(str(self.operand_left))
self.num_2_label.setText(str(self.operand_right))
self.sign_label.setText(operator)
self.answer_field.clear()
self.answer_field.setFocus(True)
def check_answer(self):
answer = self.answer_field.text()
cur_pos = self.answer_field.cursorPosition()
if len(answer) and int(answer) == self.correct_answer:
self.show_next_example()
self.counter += 1
self.counter_label.setText(str(self.counter))
return
self.answer_field.setFocus(True)
self.answer_field.setCursorPosition(cur_pos)
def stop_session(self):
"""Show results of session and emmit stop signal"""
self.timer.stop()
result_window = QMessageBox(self)
time = QTime(0, 0).secsTo(self.time)
counter = self.counter
average_time = '--undefined--'
if counter and time:
average_time = f'{round(time / counter, 1)}'
result_window.setText(
f'time: {self.time.toString()}\n\n'
f'total examples: {counter}\n\n'
f'Average time for arithmetic operation {average_time} second(s)')
result_window.exec()
self.stop_signal.emit()
def add(self, a: int, b: int):
self.operand_left = a
self.operand_right = b
self.correct_answer = self.operand_left + self.operand_right
def mul(self, a: int, b: int):
self.operand_left = a
self.operand_right = b
self.correct_answer = self.operand_left * self.operand_right
def sub(self, a: int, b: int):
self.operand_left = a + b
self.operand_right = b
self.correct_answer = self.operand_left - self.operand_right
def floordiv(self, a: int, b: int):
self.operand_left = a * b
self.operand_right = b
self.correct_answer = self.operand_left // self.operand_right
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
settings = QSettings()
self.setup_trayicon()
self.setup_ui()
self.update_work_end_time()
self.update_rest_end_time()
self.setup_connections()
self.timeFormat = "hh:mm:ss"
self.time = QTime(0, 0, 0, 0)
self.workTime = QTime(0, 0, 0, 0)
self.restTime = QTime(0, 0, 0, 0)
self.totalTime = QTime(0, 0, 0, 0)
self.currentMode = Mode.work
self.maxRepetitions = -1
self.currentRepetitions = 0
self.show()
def leaveEvent(self, event):
super(MainWindow, self).leaveEvent(event)
self.tasksTableWidget.clearSelection()
def closeEvent(self, event):
super(MainWindow, self).closeEvent(event)
settings = QSettings()
settings.setValue("timer/work/hours", self.workHoursSpinBox.value())
settings.setValue("timer/work/minutes",
self.workMinutesSpinBox.value())
settings.setValue("timer/work/seconds",
self.workSecondsSpinBox.value())
settings.setValue("timer/rest/hours", self.restHoursSpinBox.value())
settings.setValue("timer/rest/minutes",
self.restMinutesSpinBox.value())
settings.setValue("timer/rest/seconds",
self.restSecondsSpinBox.value())
tasks = []
for i in range(self.tasksTableWidget.rowCount()):
item = self.tasksTableWidget.item(i, 0)
if not item.font().strikeOut():
tasks.append(item.text())
settings.setValue("tasks/tasks", tasks)
def start_timer(self):
try:
if not self.timer.isActive():
self.create_timer()
except:
self.create_timer()
def create_timer(self):
self.timer = QTimer()
self.timer.timeout.connect(self.update_time)
self.timer.timeout.connect(self.maybe_change_mode)
self.timer.setInterval(1000)
self.timer.setSingleShot(False)
self.timer.start()
def pause_timer(self):
try:
self.timer.stop()
self.timer.disconnect()
except:
pass
def reset_timer(self):
try:
self.pause_timer()
self.time = QTime(0, 0, 0, 0)
self.display_time()
except:
pass
def maybe_start_timer(self):
if self.currentRepetitions != self.maxRepetitions:
self.start_timer()
started = True
else:
self.currentRepetitions = 0
started = False
return started
def update_work_end_time(self):
self.workEndTime = QTime(self.workHoursSpinBox.value(),
self.workMinutesSpinBox.value(),
self.workSecondsSpinBox.value())
def update_rest_end_time(self):
self.restEndTime = QTime(self.restHoursSpinBox.value(),
self.restMinutesSpinBox.value(),
self.restSecondsSpinBox.value())
def update_current_mode(self, mode: str):
self.currentMode = Mode.work if mode == "work" else Mode.rest
def update_time(self):
self.time = self.time.addSecs(1)
self.totalTime = self.totalTime.addSecs(1)
if self.modeComboBox.currentText() == "work":
self.workTime = self.workTime.addSecs(1)
else:
self.restTime = self.restTime.addSecs(1)
self.display_time()
def update_max_repetitions(self, value):
if value == 0:
self.currentRepetitions = 0
self.maxRepetitions = -1
else:
self.maxRepetitions = 2 * value
def maybe_change_mode(self):
if self.currentMode is Mode.work and self.time >= self.workEndTime:
self.reset_timer()
self.modeComboBox.setCurrentIndex(1)
self.increment_current_repetitions()
started = self.maybe_start_timer()
self.show_window_message(
Status.workFinished if started else Status.repetitionsReached)
elif self.currentMode is Mode.rest and self.time >= self.restEndTime:
self.reset_timer()
self.modeComboBox.setCurrentIndex(0)
self.increment_current_repetitions()
started = self.maybe_start_timer()
self.show_window_message(
Status.restFinished if started else Status.repetitionsReached)
def increment_current_repetitions(self):
if self.maxRepetitions > 0:
self.currentRepetitions += 1
def insert_task(self):
task = self.taskTextEdit.toPlainText()
self.insert_tasks(task)
def insert_tasks(self, *tasks):
for task in tasks:
if task:
rowCount = self.tasksTableWidget.rowCount()
self.tasksTableWidget.setRowCount(rowCount + 1)
self.tasksTableWidget.setItem(rowCount, 0,
QTableWidgetItem(task))
self.tasksTableWidget.resizeRowsToContents()
self.taskTextEdit.clear()
def delete_task(self):
selectedIndexes = self.tasksTableWidget.selectedIndexes()
if selectedIndexes:
self.tasksTableWidget.removeRow(selectedIndexes[0].row())
def mark_task_as_finished(self, row, col):
item = self.tasksTableWidget.item(row, col)
font = self.tasksTableWidget.item(row, col).font()
font.setStrikeOut(False if item.font().strikeOut() else True)
item.setFont(font)
def display_time(self):
self.timeDisplay.display(self.time.toString(self.timeFormat))
self.statisticsRestTimeDisplay.display(
self.restTime.toString(self.timeFormat))
self.statisticsWorkTimeDisplay.display(
self.workTime.toString(self.timeFormat))
self.statisticsTotalTimeDisplay.display(
self.totalTime.toString(self.timeFormat))
def show_window_message(self, status):
if status is Status.workFinished:
self.trayIcon.showMessage("Break", choice(work_finished_phrases),
QIcon("icons/tomato.png"))
elif status is Status.restFinished:
self.trayIcon.showMessage("Work", choice(rest_finished_phrases),
QIcon("icons/tomato.png"))
else:
self.trayIcon.showMessage("Finished",
choice(pomodoro_finished_phrases),
QIcon("icons/tomato.png"))
self.resetButton.click()
def setup_connections(self):
self.playButton.clicked.connect(self.start_timer)
self.playButton.clicked.connect(
lambda: self.playButton.setDisabled(True))
self.playButton.clicked.connect(
lambda: self.pauseButton.setDisabled(False))
self.playButton.clicked.connect(
lambda: self.resetButton.setDisabled(False))
self.pauseButton.clicked.connect(self.pause_timer)
self.pauseButton.clicked.connect(
lambda: self.playButton.setDisabled(False))
self.pauseButton.clicked.connect(
lambda: self.pauseButton.setDisabled(True))
self.pauseButton.clicked.connect(
lambda: self.resetButton.setDisabled(False))
self.resetButton.clicked.connect(self.reset_timer)
self.resetButton.clicked.connect(
lambda: self.playButton.setDisabled(False))
self.resetButton.clicked.connect(
lambda: self.pauseButton.setDisabled(True))
self.resetButton.clicked.connect(
lambda: self.resetButton.setDisabled(True))
self.workHoursSpinBox.valueChanged.connect(self.update_work_end_time)
self.workMinutesSpinBox.valueChanged.connect(self.update_work_end_time)
self.workSecondsSpinBox.valueChanged.connect(self.update_work_end_time)
self.restHoursSpinBox.valueChanged.connect(self.update_rest_end_time)
self.restMinutesSpinBox.valueChanged.connect(self.update_rest_end_time)
self.restSecondsSpinBox.valueChanged.connect(self.update_rest_end_time)
self.modeComboBox.currentTextChanged.connect(self.update_current_mode)
self.repetitionsSpinBox.valueChanged.connect(
self.update_max_repetitions)
self.acceptTaskButton.pressed.connect(self.insert_task)
self.deleteTaskButton.pressed.connect(self.delete_task)
self.tasksTableWidget.cellDoubleClicked.connect(
self.mark_task_as_finished)
def setup_ui(self):
settings = QSettings()
self.size_policy = sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
#TABWIDGET
self.tabWidget = QTabWidget()
self.pomodoroWidget = QWidget(self)
self.pomodoroWidgetLayout = QVBoxLayout(self.pomodoroWidget)
self.pomodoroWidget.setLayout(self.pomodoroWidgetLayout)
# work
self.workGroupBox = QGroupBox("Work")
self.workGroupBoxLayout = QHBoxLayout(self.workGroupBox)
self.workGroupBox.setLayout(self.workGroupBoxLayout)
self.workHoursSpinBox = QSpinBox(minimum=0,
maximum=24,
value=settings.value(
"timer/work/hours", 0),
suffix="h",
sizePolicy=self.size_policy)
self.workMinutesSpinBox = QSpinBox(minimum=0,
maximum=60,
value=settings.value(
"timer/work/minutes", 25),
suffix="m",
sizePolicy=self.size_policy)
self.workSecondsSpinBox = QSpinBox(minimum=0,
maximum=60,
value=settings.value(
"timer/work/seconds", 0),
suffix="s",
sizePolicy=self.size_policy)
self.workGroupBoxLayout.addWidget(self.workHoursSpinBox)
self.workGroupBoxLayout.addWidget(self.workMinutesSpinBox)
self.workGroupBoxLayout.addWidget(self.workSecondsSpinBox)
# rest
self.restGroupBox = QGroupBox("Rest")
self.restGroupBoxLayout = QHBoxLayout(self.restGroupBox)
self.restGroupBox.setLayout(self.restGroupBoxLayout)
self.restHoursSpinBox = QSpinBox(minimum=0,
maximum=24,
value=settings.value(
"timer/rest/hours", 0),
suffix="h",
sizePolicy=self.size_policy)
self.restMinutesSpinBox = QSpinBox(minimum=0,
maximum=60,
value=settings.value(
"timer/rest/minutes", 5),
suffix="m",
sizePolicy=self.size_policy)
self.restSecondsSpinBox = QSpinBox(minimum=0,
maximum=60,
value=settings.value(
"timer/rest/seconds", 0),
suffix="s",
sizePolicy=self.size_policy)
self.restGroupBoxLayout.addWidget(self.restHoursSpinBox)
self.restGroupBoxLayout.addWidget(self.restMinutesSpinBox)
self.restGroupBoxLayout.addWidget(self.restSecondsSpinBox)
#OTHER
self.otherGroupBox = QGroupBox("Other")
self.otherGroupBoxLayout = QHBoxLayout(self.otherGroupBox)
self.otherGroupBox.setLayout(self.otherGroupBoxLayout)
self.repetitionsLabel = QLabel("Repetitions",
sizePolicy=self.size_policy)
self.repetitionsSpinBox = QSpinBox(minimum=0,
maximum=10000,
value=0,
sizePolicy=self.size_policy,
specialValueText="∞")
self.modeLabel = QLabel("Mode", sizePolicy=self.size_policy)
self.modeComboBox = QComboBox()
self.modeComboBox.addItems(["work", "rest"])
self.otherGroupBoxLayout.addWidget(self.repetitionsLabel)
self.otherGroupBoxLayout.addWidget(self.repetitionsSpinBox)
self.otherGroupBoxLayout.addWidget(self.modeLabel)
self.otherGroupBoxLayout.addWidget(self.modeComboBox)
#LCDDISPLAY
self.lcdDisplayGroupBox = QGroupBox("Time")
self.lcdDisplayGroupBoxLayout = QHBoxLayout(self.lcdDisplayGroupBox)
self.lcdDisplayGroupBox.setLayout(self.lcdDisplayGroupBoxLayout)
self.timeDisplay = QLCDNumber(8, sizePolicy=self.size_policy)
self.timeDisplay.setFixedHeight(100)
self.timeDisplay.display("00:00:00")
self.lcdDisplayGroupBoxLayout.addWidget(self.timeDisplay)
#BUTTONS
self.buttonWidget = QWidget()
self.buttonWidgetLayout = QHBoxLayout(self.buttonWidget)
self.buttonWidget.setLayout(self.buttonWidgetLayout)
self.playButton = self.make_button("start", disabled=False)
self.resetButton = self.make_button("reset")
self.pauseButton = self.make_button("pause")
self.buttonWidgetLayout.addWidget(self.pauseButton)
self.buttonWidgetLayout.addWidget(self.playButton)
self.buttonWidgetLayout.addWidget(self.resetButton)
#CENTRALWIDGET
self.pomodoroWidgetLayout.addWidget(self.workGroupBox)
self.pomodoroWidgetLayout.addWidget(self.restGroupBox)
self.pomodoroWidgetLayout.addWidget(self.otherGroupBox)
self.pomodoroWidgetLayout.addWidget(self.lcdDisplayGroupBox)
self.pomodoroWidgetLayout.addWidget(self.buttonWidget)
#CREATE TASKS TAB
self.tasksWidget = QWidget(self.tabWidget)
self.tasksWidgetLayout = QVBoxLayout(self.tasksWidget)
self.tasksWidget.setLayout(self.tasksWidgetLayout)
self.inputWidget = QWidget()
self.inputWidget.setFixedHeight(50)
self.inputWidgetLayout = QHBoxLayout(self.inputWidget)
self.inputWidgetLayout.setContentsMargins(0, 0, 0, 0)
self.inputWidget.setLayout(self.inputWidgetLayout)
self.taskTextEdit = QTextEdit(
placeholderText="Describe your task briefly.",
undoRedoEnabled=True)
self.inputButtonContainer = QWidget()
self.inputButtonContainerLayout = QVBoxLayout(
self.inputButtonContainer)
self.inputButtonContainerLayout.setContentsMargins(0, 0, 0, 0)
self.inputButtonContainer.setLayout(self.inputButtonContainerLayout)
self.acceptTaskButton = QToolButton(icon=QIcon("icons/check.png"))
self.deleteTaskButton = QToolButton(icon=QIcon("icons/trash.png"))
self.inputButtonContainerLayout.addWidget(self.acceptTaskButton)
self.inputButtonContainerLayout.addWidget(self.deleteTaskButton)
self.inputWidgetLayout.addWidget(self.taskTextEdit)
self.inputWidgetLayout.addWidget(self.inputButtonContainer)
self.tasksTableWidget = QTableWidget(0, 1)
self.tasksTableWidget.setHorizontalHeaderLabels(["Tasks"])
self.tasksTableWidget.horizontalHeader().setStretchLastSection(True)
self.tasksTableWidget.verticalHeader().setVisible(False)
self.tasksTableWidget.setWordWrap(True)
self.tasksTableWidget.setTextElideMode(Qt.ElideNone)
self.tasksTableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tasksTableWidget.setSelectionMode(
QAbstractItemView.SingleSelection)
self.insert_tasks(*settings.value("tasks/tasks", []))
self.tasksWidgetLayout.addWidget(self.inputWidget)
self.tasksWidgetLayout.addWidget(self.tasksTableWidget)
#CREATE STATISTICS TAB
self.statisticsWidget = QWidget()
self.statisticsWidgetLayout = QVBoxLayout(self.statisticsWidget)
self.statisticsWidget.setLayout(self.statisticsWidgetLayout)
self.statisticsWorkTimeGroupBox = QGroupBox("Work Time")
self.statisticsWorkTimeGroupBoxLayout = QHBoxLayout()
self.statisticsWorkTimeGroupBox.setLayout(
self.statisticsWorkTimeGroupBoxLayout)
self.statisticsWorkTimeDisplay = QLCDNumber(8)
self.statisticsWorkTimeDisplay.display("00:00:00")
self.statisticsWorkTimeGroupBoxLayout.addWidget(
self.statisticsWorkTimeDisplay)
self.statisticsRestTimeGroupBox = QGroupBox("Rest Time")
self.statisticsRestTimeGroupBoxLayout = QHBoxLayout()
self.statisticsRestTimeGroupBox.setLayout(
self.statisticsRestTimeGroupBoxLayout)
self.statisticsRestTimeDisplay = QLCDNumber(8)
self.statisticsRestTimeDisplay.display("00:00:00")
self.statisticsRestTimeGroupBoxLayout.addWidget(
self.statisticsRestTimeDisplay)
self.statisticsTotalTimeGroupBox = QGroupBox("Total Time")
self.statisticsTotalTimeGroupBoxLayout = QHBoxLayout()
self.statisticsTotalTimeGroupBox.setLayout(
self.statisticsTotalTimeGroupBoxLayout)
self.statisticsTotalTimeDisplay = QLCDNumber(8)
self.statisticsTotalTimeDisplay.display("00:00:00")
self.statisticsTotalTimeGroupBoxLayout.addWidget(
self.statisticsTotalTimeDisplay)
self.statisticsWidgetLayout.addWidget(self.statisticsTotalTimeGroupBox)
self.statisticsWidgetLayout.addWidget(self.statisticsWorkTimeGroupBox)
self.statisticsWidgetLayout.addWidget(self.statisticsRestTimeGroupBox)
#ADD TABS
self.timerTab = self.tabWidget.addTab(self.pomodoroWidget,
QIcon("icons/timer.png"),
"Timer")
self.tasksTab = self.tabWidget.addTab(self.tasksWidget,
QIcon("icons/tasks.png"),
"Tasks")
self.statisticsTab = self.tabWidget.addTab(
self.statisticsWidget, QIcon("icons/statistics.png"), "Statistics")
self.setCentralWidget(self.tabWidget)
def make_button(self, text, iconPath=None, disabled=True):
button = QPushButton(text, sizePolicy=self.size_policy)
if iconPath:
button.setIcon(QIcon(iconPath))
button.setDisabled(disabled)
return button
def setup_trayicon(self):
self.trayIcon = QSystemTrayIcon(QIcon("icons/tomato.png"))
self.trayIcon.setContextMenu(QMenu())
self.quitAction = self.trayIcon.contextMenu().addAction(
QIcon("icons/exit.png"), "Quit", self.exit)
self.quitAction.triggered.connect(self.exit)
self.trayIcon.activated.connect(self.onActivate)
self.trayIcon.show()
def exit(self):
self.close()
app = QApplication.instance()
if app:
app.quit()
def onActivate(self, reason):
if reason == QSystemTrayIcon.Trigger:
self.show()
class ButtonPane(QWidget):
manage_ranking = pyqtSignal(str)
def __init__(self, width, height, bombs, diff, matrix, m_sum, path_matrix,
saving, restoring, on_configure):
super().__init__()
self.diff = diff # Difficoltà
self.saving = saving
self.restoring = restoring
self.setStyleSheet("font: 16px Andale Mono")
QVLayout = QVBoxLayout(self)
area_info = QWidget()
area_info.setStyleSheet(
"background-color: gray; border: 1px solid black")
QHLayout = QHBoxLayout(area_info)
self.label_1 = QLabel(str(bombs))
self.label_1.setFixedSize(QSize(80, 30))
self.label_1.setAlignment(Qt.AlignCenter)
self.label_1.setStyleSheet(
"background-color: black; color: red; border-radius: 5px; border: 1px solid black"
)
label_2 = QPushButton()
label_2.setFixedSize(QSize(60, 60))
label_2.setIcon(QIcon(sys.path[0] + '/Images/sun-smile.png'))
label_2.setIconSize(QSize(60, 60))
label_2.clicked.connect(on_configure)
self.label_3 = QLabel('Tempo')
self.label_3.setFixedSize(QSize(80, 30))
self.label_3.setAlignment(Qt.AlignCenter)
self.label_3.setStyleSheet(
"background-color: black; color: red; border-radius: 5px; border: 1px solid black"
)
self.curr_time = QTime(00, 00, 00)
self.timer = QTimer()
self.timer.timeout.connect(self.timerEvent)
area_game = QWidget()
area_game.setStyleSheet("border: 1px solid black")
buttons_layout = QGridLayout(area_game)
buttons_layout.setSpacing(0)
self.btn_matrix = [[0 for _ in range(height)] for _ in range(width)]
# Generazione della griglia di gioco
for i in range(width):
for j in range(height):
btn = MinesweeperButton(row=i,
col=j,
bombs=bombs,
diff=diff,
matrix=matrix,
m_sum=m_sum,
path_matrix=path_matrix,
bomb_label=self.label_1,
img=label_2)
buttons_layout.addWidget(btn, i, j)
btn.update_button.connect(self.update_game)
btn.defeat_signal.connect(self.manage_defeat)
btn.win_signal.connect(self.manage_win)
self.btn_matrix[i][j] = btn
QHLayout.addWidget(self.label_1)
QHLayout.addWidget(label_2)
QHLayout.addWidget(self.label_3)
self.name_zone = QWidget()
horizontal_layout = QHBoxLayout(self.name_zone)
label_name = QLabel('Nome:')
self.name = QLineEdit()
self.submit_btn = QPushButton('Go!')
horizontal_layout.addWidget(label_name)
horizontal_layout.addWidget(self.name)
horizontal_layout.addWidget(self.submit_btn)
self.name_zone.hide()
QVLayout.addWidget(area_info)
QVLayout.addWidget(area_game)
QVLayout.addWidget(self.name_zone)
def update_game(
self, game_over
): # Aggiornamento dello stato delle caselle componenti la griglia
for index_row, row in enumerate(self.btn_matrix):
for index_col, col in enumerate(row):
self.btn_matrix[index_row][index_col].update(game_over)
def timerEvent(self): # Aggiormamento del timer
self.curr_time = self.curr_time.addSecs(1)
self.label_3.setText(self.curr_time.toString("hh:mm:ss"))
def manage_win(self): # Gestione del segnale indicante la vittoria
self.timer.stop()
self.saving.setDisabled(True)
self.restoring.setDisabled(True)
self.manage_ranking.emit(self.curr_time.toString("hh:mm:ss"))
if (os.path.isfile(sys.path[0] + '/Temp/objs.pkl')):
os.remove(sys.path[0] + '/Temp/objs.pkl')
def manage_defeat(self): # Gestione del segnale indicante la sconfitta
self.timer.stop()
self.saving.setDisabled(True)
self.restoring.setDisabled(True)
if (os.path.isfile(sys.path[0] + '/Temp/objs.pkl')):
os.remove(sys.path[0] + '/Temp/objs.pkl')
class Timer(QWidget):
def __init__(self):
super().__init__()
self.widget = QWidget(self)
self.widget.setObjectName("main")
self.widget.setStyleSheet("""
QWidget#main{
border:1px solid #148CD2;
border-radius:10px;
margin:0
}
""")
layout = QVBoxLayout()
fnt = QFont('Open Sans', 60, QFont.Bold)
self.lbl = QLabel()
self.lbl.setAlignment(Qt.AlignCenter)
self.currentTime = QTime(0,0,0)
self.lbl.setFont(fnt)
timer = QTimer(self)
timer.timeout.connect(self.showTime)
timer.start(1000) # update every second
self.btnStart = QPushButton('Start', self)
self.btnStart.setStyleSheet(
"""
QPushButton
{
margin-right:20px;
}
QPushButton:hover
{
background-color:#148CD2;
border:none;
}
""")
line = QFormLayout()
line.setContentsMargins(0,20,0,0)
self.msg = QLabel("Elapsed Time")
fnt2 = QFont('Open Sans', 28)
self.msg.setFont(fnt2)
self.btnStart.setFixedSize(100,50)
self.btnStart.clicked.connect(self.startProgress)
self.showTime()
self.timerStatus = False
line.addRow(self.btnStart,self.msg)
layout.addWidget(self.lbl)
layout.addItem(line)
self.widget.setLayout(layout)
self.widget.setFixedSize(400,200)
Classifiertimer = QTimer(self)
Classifiertimer.timeout.connect(self.ClassifierRunner)
Classifiertimer.start(60*1000) # update every minute
def showTime(self):
if self.btnStart.text() == 'Stop':
self.currentTime = self.currentTime.addSecs(1)
displayTxt = self.currentTime.toString('hh:mm:ss')
self.lbl.setText(displayTxt)
else:
displayTxt = self.currentTime.toString('hh:mm:ss')
self.lbl.setText(displayTxt)
def startProgress(self):
if self.btnStart.text() == 'Start':
self.btnStart.setText('Stop')
self.timerStatus = True
else:
self.btnStart.setText('Start')
self.currentTime = QTime(0,0,0)
self.timerStatus = False
def ClassifierRunner(self):
Classifier(self.timerStatus)
class MainWindow(QWidget):
def __init__(self):
super().__init__()
self.backlogMgr = BacklogMgr()
self.initUI()
def initUI(self):
self.setWindowTitle("TurboClock")
self.resize(400, 300)
self.setWindowIcon(QIcon('Images//clock.png'))
self.icon = QSystemTrayIcon(self)
self.icon.setIcon(QIcon('Images//clock.png'))
self.icon.setVisible(True)
self.lcdNumber = QLCDNumber()
self.lcdNumber.setNumDigits(8)
self.btnStartPause = QPushButton('', self)
self.btnStartPause.setIcon(QIcon('Images//play_icon.png'))
self.btnStartPause.clicked.connect(self.manageStartPauseClickedEvent)
self.btnDutyDetails = QPushButton('Duty details...')
self.btnDutyDetails.clicked.connect(self.manageDutyDetailsClickedEvent)
self.btnAddTfsTask = QPushButton('', self)
self.btnAddTfsTask.setIcon(QIcon('Images//plus_icon.png'))
self.btnAddTfsTask.clicked.connect(self.manageEditTasksOptions)
self.progressBar = QProgressBar()
self.progressBar.setValue(0)
self.dutyTimeCompLbl = QLabel()
self.currTaskItemRow = 0
self.taskTFSCb = QComboBox(self)
self.initTFSTaskCombobox()
mainLayout = QVBoxLayout(self)
layoutTimer = QVBoxLayout()
layoutTimer.addWidget(self.lcdNumber)
fieldsInputLayout = QHBoxLayout()
layoutInputCodes = QVBoxLayout()
layoutInputCodes.addWidget(self.taskTFSCb)
layoutAddBtn = QVBoxLayout()
layoutAddBtn.addWidget(self.btnAddTfsTask)
fieldsInputLayout.addLayout(layoutInputCodes)
fieldsInputLayout.addLayout(layoutAddBtn)
layoutDutyStat = QHBoxLayout()
layoutDutyStat.addWidget(self.dutyTimeCompLbl)
layoutProgressBar = QHBoxLayout()
layoutProgressBar.addWidget(self.progressBar)
mainLayout.addLayout(layoutTimer)
mainLayout.addLayout(fieldsInputLayout)
mainLayout.addWidget(self.btnStartPause)
mainLayout.addWidget(self.btnDutyDetails)
mainLayout.addWidget(self.progressBar)
mainLayout.addLayout(layoutDutyStat)
self.timer = QTimer(self)
self.deltaTimer = 0
self.currTimeLCD = QTime(0, 0, 0)
self.currTimeDuty = QTime(0, 0, 0)
self.timer.timeout.connect(self.incrementTimer)
self.updateTimeLCD()
self.updateDutyTimeDisp()
self.updateProgressBarDisplay()
self.startTime = 0
self.stopTime = 0
self.editTasksGUI = EditTasksOptionsGUI(self, self.backlogMgr)
def initTFSTaskCombobox(self):
self.updateTaskCombobox()
self.taskTFSCb.currentIndexChanged.connect(self.manageCbTFSIndexChange)
def updateProgressBarDisplay(self):
estimatedTime = self.backlogMgr.backlogData.currTask.estimatedTime
if estimatedTime == 0:
return
ratioFromTimer = (self.deltaTimer / estimatedTime) * 100
totalCompletionRatio = self.backlogMgr.getCompletionRatio(
self.backlogMgr.backlogData.currTaskIndex) + ratioFromTimer
if totalCompletionRatio <= 100:
self.progressBar.setValue(totalCompletionRatio)
else:
self.progressBar.setValue(100)
def updateTaskCombobox(self):
currTaskIndex = self.currTaskItemRow
self.taskTFSCb.clear()
taskList = self.backlogMgr.getTasksFromGUI()
for currTask in taskList:
taskDesc = currTask.title + ' (' + currTask.prjCode + ')'
self.taskTFSCb.addItem(taskDesc)
self.taskTFSCb.setCurrentIndex(currTaskIndex)
self.backlogMgr.setCurrentTaskFromGUI(currTaskIndex)
def manageCbTFSIndexChange(self):
self.currTaskItemRow = self.taskTFSCb.currentIndex()
if self.currTaskItemRow >= 0:
self.backlogMgr.manageTaskChangeFromGUI(self.currTaskItemRow)
self.updateTimeLCD()
self.deltaTimer = 0
self.updateProgressBarDisplay()
def updateTimeLCD(self):
currTaskTime_split = self.backlogMgr.getCompletedTimeCurrTaskFromGUI(
).split(':')
h = int(currTaskTime_split[0])
m = int(currTaskTime_split[1])
s = int(currTaskTime_split[2])
self.currTimeLCD = QTime(h, m, s)
self.lcdNumber.display(self.currTimeLCD.toString('hh:mm:ss'))
def updateDutyTimeDisp(self):
currTaskTime_split = self.backlogMgr.getCurrDutyTimeCompletedFromGUI(
).split(':')
h = int(currTaskTime_split[0])
m = int(currTaskTime_split[1])
s = int(currTaskTime_split[2])
self.currTimeDuty = QTime(h, m, s)
self.dutyTimeCompLbl.setText('Daily time completed: ' +
self.currTimeDuty.toString('hh:mm:ss'))
def incrementTimer(self):
self.currTimeLCD = self.currTimeLCD.addSecs(1)
self.lcdNumber.display(self.currTimeLCD.toString('hh:mm:ss'))
self.currTimeDuty = self.currTimeDuty.addSecs(1)
self.dutyTimeCompLbl.setText('Daily time completed: ' +
self.currTimeDuty.toString('hh:mm:ss'))
self.deltaTimer += 1
self.updateProgressBarDisplay()
def manageStartPauseClickedEvent(self):
self.backlogMgr.manageClickButtonFromGUI()
self.deltaTimer = 0
if self.timer.isActive():
self.timer.stop()
self.btnStartPause.setIcon(QIcon('Images//play_icon.png'))
else:
self.timer.start(1000)
self.btnStartPause.setIcon(QIcon('Images//pause_icon.png'))
def manageDutyDetailsClickedEvent(self):
ex = DutyDetailsWindow(self, self.backlogMgr.backlogData)
ex.show()
def manageEditTasksOptions(self):
self.editTasksGUI.exec_()
self.updateTaskCombobox()
def closeEvent(self, event):
event.accept()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.setupTrayicon()
self.setupVariables()
self.setupUi()
self.setupConnections()
self.show()
def setupVariables(self):
settings = QSettings()
self.workEndTime = QTime(
int(settings.value(workHoursKey, 0)),
int(settings.value(workMinutesKey, 25)),
int(settings.value(workSecondsKey, 0)),
)
self.restEndTime = QTime(
int(settings.value(restHoursKey, 0)),
int(settings.value(restMinutesKey, 5)),
int(settings.value(restSecondsKey, 0)),
)
self.timeFormat = "hh:mm:ss"
self.time = QTime(0, 0, 0, 0)
self.workTime = QTime(0, 0, 0, 0)
self.restTime = QTime(0, 0, 0, 0)
self.totalTime = QTime(0, 0, 0, 0)
self.currentMode = Mode.work
self.maxRepetitions = -1
self.currentRepetitions = 0
def setupConnections(self):
""" Create button connections """
self.startButton.clicked.connect(self.startTimer)
self.startButton.clicked.connect(
lambda: self.startButton.setDisabled(True))
self.startButton.clicked.connect(
lambda: self.pauseButton.setDisabled(False))
self.startButton.clicked.connect(
lambda: self.resetButton.setDisabled(False))
self.pauseButton.clicked.connect(self.pauseTimer)
self.pauseButton.clicked.connect(
lambda: self.startButton.setDisabled(False))
self.pauseButton.clicked.connect(
lambda: self.pauseButton.setDisabled(True))
self.pauseButton.clicked.connect(
lambda: self.resetButton.setDisabled(False))
self.pauseButton.clicked.connect(
lambda: self.startButton.setText("continue"))
self.resetButton.clicked.connect(self.resetTimer)
self.resetButton.clicked.connect(
lambda: self.startButton.setDisabled(False))
self.resetButton.clicked.connect(
lambda: self.pauseButton.setDisabled(True))
self.resetButton.clicked.connect(
lambda: self.resetButton.setDisabled(True))
self.resetButton.clicked.connect(
lambda: self.startButton.setText("start"))
self.acceptTaskButton.pressed.connect(self.insertTask)
self.deleteTaskButton.pressed.connect(self.deleteTask)
""" Create spinbox connections """
self.workHoursSpinBox.valueChanged.connect(self.updateWorkEndTime)
self.workMinutesSpinBox.valueChanged.connect(self.updateWorkEndTime)
self.workSecondsSpinBox.valueChanged.connect(self.updateWorkEndTime)
self.restHoursSpinBox.valueChanged.connect(self.updateRestEndTime)
self.restMinutesSpinBox.valueChanged.connect(self.updateRestEndTime)
self.restSecondsSpinBox.valueChanged.connect(self.updateRestEndTime)
self.repetitionsSpinBox.valueChanged.connect(self.updateMaxRepetitions)
""" Create combobox connections """
self.modeComboBox.currentTextChanged.connect(self.updateCurrentMode)
""" Create tablewidget connections """
self.tasksTableWidget.cellDoubleClicked.connect(
self.markTaskAsFinished)
def setupUi(self):
self.size_policy = sizePolicy = QSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
""" Create tabwidget """
self.tabWidget = QTabWidget()
""" Create tab widgets """
timerWidget = self.setupTimerTab()
tasksWidget = self.setupTasksTab()
statisticsWidget = self.setupStatisticsTab()
""" add tab widgets to tabwidget"""
self.timerTab = self.tabWidget.addTab(timerWidget, makeIcon("timer"),
"Timer")
self.tasksTab = self.tabWidget.addTab(tasksWidget, makeIcon("tasks"),
"Tasks")
self.statisticsTab = self.tabWidget.addTab(statisticsWidget,
makeIcon("statistics"),
"Statistics")
""" Set mainwindows central widget """
self.setCentralWidget(self.tabWidget)
def setupTimerTab(self):
settings = QSettings()
self.timerContainer = QWidget(self)
self.timerContainerLayout = QVBoxLayout(self.timerContainer)
self.timerContainer.setLayout(self.timerContainerLayout)
""" Create work groupbox"""
self.workGroupBox = QGroupBox("Work")
self.workGroupBoxLayout = QHBoxLayout(self.workGroupBox)
self.workGroupBox.setLayout(self.workGroupBoxLayout)
self.workHoursSpinBox = QSpinBox(
minimum=0,
maximum=24,
value=int(settings.value(workHoursKey, 0)),
suffix="h",
sizePolicy=self.size_policy,
)
self.workMinutesSpinBox = QSpinBox(
minimum=0,
maximum=60,
value=int(settings.value(workMinutesKey, 25)),
suffix="m",
sizePolicy=self.size_policy,
)
self.workSecondsSpinBox = QSpinBox(
minimum=0,
maximum=60,
value=int(settings.value(workSecondsKey, 0)),
suffix="s",
sizePolicy=self.size_policy,
)
""" Create rest groupbox"""
self.restGroupBox = QGroupBox("Rest")
self.restGroupBoxLayout = QHBoxLayout(self.restGroupBox)
self.restGroupBox.setLayout(self.restGroupBoxLayout)
self.restHoursSpinBox = QSpinBox(
minimum=0,
maximum=24,
value=int(settings.value(restHoursKey, 0)),
suffix="h",
sizePolicy=self.size_policy,
)
self.restMinutesSpinBox = QSpinBox(
minimum=0,
maximum=60,
value=int(settings.value(restMinutesKey, 5)),
suffix="m",
sizePolicy=self.size_policy,
)
self.restSecondsSpinBox = QSpinBox(
minimum=0,
maximum=60,
value=int(settings.value(restSecondsKey, 0)),
suffix="s",
sizePolicy=self.size_policy,
)
self.restGroupBoxLayout.addWidget(self.restHoursSpinBox)
self.restGroupBoxLayout.addWidget(self.restMinutesSpinBox)
self.restGroupBoxLayout.addWidget(self.restSecondsSpinBox)
""" Create other groupbox"""
self.otherGroupBox = QGroupBox("Other")
self.otherGroupBoxLayout = QHBoxLayout(self.otherGroupBox)
self.otherGroupBox.setLayout(self.otherGroupBoxLayout)
self.repetitionsLabel = QLabel("Repetitions")
self.repetitionsSpinBox = QSpinBox(
minimum=0,
maximum=10000,
value=0,
sizePolicy=self.size_policy,
specialValueText="∞",
)
self.modeLabel = QLabel("Mode")
self.modeComboBox = QComboBox(sizePolicy=self.size_policy)
self.modeComboBox.addItems(["work", "rest"])
self.otherGroupBoxLayout.addWidget(self.repetitionsLabel)
self.otherGroupBoxLayout.addWidget(self.repetitionsSpinBox)
self.otherGroupBoxLayout.addWidget(self.modeLabel)
self.otherGroupBoxLayout.addWidget(self.modeComboBox)
""" Create timer groupbox"""
self.lcdDisplayGroupBox = QGroupBox("Time")
self.lcdDisplayGroupBoxLayout = QHBoxLayout(self.lcdDisplayGroupBox)
self.lcdDisplayGroupBox.setLayout(self.lcdDisplayGroupBoxLayout)
self.timeDisplay = QLCDNumber(8, sizePolicy=self.size_policy)
self.timeDisplay.setFixedHeight(100)
self.timeDisplay.display("00:00:00")
self.lcdDisplayGroupBoxLayout.addWidget(self.timeDisplay)
""" Create pause, start and reset buttons"""
self.buttonContainer = QWidget()
self.buttonContainerLayout = QHBoxLayout(self.buttonContainer)
self.buttonContainer.setLayout(self.buttonContainerLayout)
self.startButton = self.makeButton("start", disabled=False)
self.resetButton = self.makeButton("reset")
self.pauseButton = self.makeButton("pause")
""" Add widgets to container """
self.workGroupBoxLayout.addWidget(self.workHoursSpinBox)
self.workGroupBoxLayout.addWidget(self.workMinutesSpinBox)
self.workGroupBoxLayout.addWidget(self.workSecondsSpinBox)
self.timerContainerLayout.addWidget(self.workGroupBox)
self.timerContainerLayout.addWidget(self.restGroupBox)
self.timerContainerLayout.addWidget(self.otherGroupBox)
self.timerContainerLayout.addWidget(self.lcdDisplayGroupBox)
self.buttonContainerLayout.addWidget(self.pauseButton)
self.buttonContainerLayout.addWidget(self.startButton)
self.buttonContainerLayout.addWidget(self.resetButton)
self.timerContainerLayout.addWidget(self.buttonContainer)
return self.timerContainer
def setupTasksTab(self):
settings = QSettings()
""" Create vertical tasks container """
self.tasksWidget = QWidget(self.tabWidget)
self.tasksWidgetLayout = QVBoxLayout(self.tasksWidget)
self.tasksWidget.setLayout(self.tasksWidgetLayout)
""" Create horizontal input container """
self.inputContainer = QWidget()
self.inputContainer.setFixedHeight(50)
self.inputContainerLayout = QHBoxLayout(self.inputContainer)
self.inputContainerLayout.setContentsMargins(0, 0, 0, 0)
self.inputContainer.setLayout(self.inputContainerLayout)
""" Create text edit """
self.taskTextEdit = QTextEdit(
placeholderText="Describe your task briefly.",
undoRedoEnabled=True)
""" Create vertical buttons container """
self.inputButtonContainer = QWidget()
self.inputButtonContainerLayout = QVBoxLayout(
self.inputButtonContainer)
self.inputButtonContainerLayout.setContentsMargins(0, 0, 0, 0)
self.inputButtonContainer.setLayout(self.inputButtonContainerLayout)
""" Create buttons """
self.acceptTaskButton = QToolButton(icon=makeIcon("check"))
self.deleteTaskButton = QToolButton(icon=makeIcon("trash"))
""" Create tasks tablewidget """
self.tasksTableWidget = QTableWidget(0, 1)
self.tasksTableWidget.setHorizontalHeaderLabels(["Tasks"])
self.tasksTableWidget.horizontalHeader().setStretchLastSection(True)
self.tasksTableWidget.verticalHeader().setVisible(False)
self.tasksTableWidget.setWordWrap(True)
self.tasksTableWidget.setTextElideMode(Qt.ElideNone)
self.tasksTableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.tasksTableWidget.setSelectionMode(
QAbstractItemView.SingleSelection)
self.insertTasks(*settings.value(tasksKey, []))
""" Add widgets to container widgets """
self.inputButtonContainerLayout.addWidget(self.acceptTaskButton)
self.inputButtonContainerLayout.addWidget(self.deleteTaskButton)
self.inputContainerLayout.addWidget(self.taskTextEdit)
self.inputContainerLayout.addWidget(self.inputButtonContainer)
self.tasksWidgetLayout.addWidget(self.inputContainer)
self.tasksWidgetLayout.addWidget(self.tasksTableWidget)
return self.tasksWidget
def setupStatisticsTab(self):
""" Create statistics container """
self.statisticsContainer = QWidget()
self.statisticsContainerLayout = QVBoxLayout(self.statisticsContainer)
self.statisticsContainer.setLayout(self.statisticsContainerLayout)
""" Create work time groupbox """
self.statisticsWorkTimeGroupBox = QGroupBox("Work Time")
self.statisticsWorkTimeGroupBoxLayout = QHBoxLayout()
self.statisticsWorkTimeGroupBox.setLayout(
self.statisticsWorkTimeGroupBoxLayout)
self.statisticsWorkTimeDisplay = QLCDNumber(8)
self.statisticsWorkTimeDisplay.display("00:00:00")
self.statisticsWorkTimeGroupBoxLayout.addWidget(
self.statisticsWorkTimeDisplay)
""" Create rest time groupbox """
self.statisticsRestTimeGroupBox = QGroupBox("Rest Time")
self.statisticsRestTimeGroupBoxLayout = QHBoxLayout()
self.statisticsRestTimeGroupBox.setLayout(
self.statisticsRestTimeGroupBoxLayout)
self.statisticsRestTimeDisplay = QLCDNumber(8)
self.statisticsRestTimeDisplay.display("00:00:00")
self.statisticsRestTimeGroupBoxLayout.addWidget(
self.statisticsRestTimeDisplay)
""" Create total time groupbox """
self.statisticsTotalTimeGroupBox = QGroupBox("Total Time")
self.statisticsTotalTimeGroupBoxLayout = QHBoxLayout()
self.statisticsTotalTimeGroupBox.setLayout(
self.statisticsTotalTimeGroupBoxLayout)
self.statisticsTotalTimeDisplay = QLCDNumber(8)
self.statisticsTotalTimeDisplay.display("00:00:00")
self.statisticsTotalTimeGroupBoxLayout.addWidget(
self.statisticsTotalTimeDisplay)
""" Add widgets to container """
self.statisticsContainerLayout.addWidget(
self.statisticsTotalTimeGroupBox)
self.statisticsContainerLayout.addWidget(
self.statisticsWorkTimeGroupBox)
self.statisticsContainerLayout.addWidget(
self.statisticsRestTimeGroupBox)
return self.statisticsContainer
def setupTrayicon(self):
self.trayIcon = QSystemTrayIcon(makeIcon("tomato"))
self.trayIcon.setContextMenu(QMenu())
self.quitAction = self.trayIcon.contextMenu().addAction(
makeIcon("exit"), "Quit", self.exit)
self.quitAction.triggered.connect(self.exit)
self.trayIcon.activated.connect(self.onActivate)
self.trayIcon.show()
def leaveEvent(self, event):
super(MainWindow, self).leaveEvent(event)
self.tasksTableWidget.clearSelection()
def closeEvent(self, event):
super(MainWindow, self).closeEvent(event)
settings = QSettings()
settings.setValue(workHoursKey, self.workHoursSpinBox.value())
settings.setValue(
workMinutesKey,
self.workMinutesSpinBox.value(),
)
settings.setValue(
workSecondsKey,
self.workSecondsSpinBox.value(),
)
settings.setValue(restHoursKey, self.restHoursSpinBox.value())
settings.setValue(
restMinutesKey,
self.restMinutesSpinBox.value(),
)
settings.setValue(
restSecondsKey,
self.restSecondsSpinBox.value(),
)
tasks = []
for i in range(self.tasksTableWidget.rowCount()):
item = self.tasksTableWidget.item(i, 0)
if not item.font().strikeOut():
tasks.append(item.text())
settings.setValue(tasksKey, tasks)
def startTimer(self):
try:
if not self.timer.isActive():
self.createTimer()
except:
self.createTimer()
def createTimer(self):
self.timer = QTimer()
self.timer.timeout.connect(self.updateTime)
self.timer.timeout.connect(self.maybeChangeMode)
self.timer.setInterval(1000)
self.timer.setSingleShot(False)
self.timer.start()
def pauseTimer(self):
try:
self.timer.stop()
self.timer.disconnect()
except:
pass
def resetTimer(self):
try:
self.pauseTimer()
self.time = QTime(0, 0, 0, 0)
self.displayTime()
except:
pass
def maybeStartTimer(self):
if self.currentRepetitions != self.maxRepetitions:
self.startTimer()
started = True
else:
self.currentRepetitions = 0
started = False
return started
def updateWorkEndTime(self):
self.workEndTime = QTime(
self.workHoursSpinBox.value(),
self.workMinutesSpinBox.value(),
self.workSecondsSpinBox.value(),
)
def updateRestEndTime(self):
self.restEndTime = QTime(
self.restHoursSpinBox.value(),
self.restMinutesSpinBox.value(),
self.restSecondsSpinBox.value(),
)
def updateCurrentMode(self, mode: str):
self.currentMode = Mode.work if mode == "work" else Mode.rest
def updateTime(self):
self.time = self.time.addSecs(1)
self.totalTime = self.totalTime.addSecs(1)
if self.modeComboBox.currentText() == "work":
self.workTime = self.workTime.addSecs(1)
else:
self.restTime = self.restTime.addSecs(1)
self.displayTime()
def updateMaxRepetitions(self, value):
if value == 0:
self.currentRepetitions = 0
self.maxRepetitions = -1
else:
self.maxRepetitions = 2 * value
def maybeChangeMode(self):
if self.currentMode is Mode.work and self.time >= self.workEndTime:
self.resetTimer()
self.modeComboBox.setCurrentIndex(1)
self.incrementCurrentRepetitions()
started = self.maybeStartTimer()
self.showWindowMessage(
Status.workFinished if started else Status.repetitionsReached)
elif self.currentMode is Mode.rest and self.time >= self.restEndTime:
self.resetTimer()
self.modeComboBox.setCurrentIndex(0)
self.incrementCurrentRepetitions()
started = self.maybeStartTimer()
self.showWindowMessage(
Status.restFinished if started else Status.repetitionsReached)
def incrementCurrentRepetitions(self):
if self.maxRepetitions > 0:
self.currentRepetitions += 1
def insertTask(self):
task = self.taskTextEdit.toPlainText()
self.insertTasks(task)
def insertTasks(self, *tasks):
for task in tasks:
if task:
rowCount = self.tasksTableWidget.rowCount()
self.tasksTableWidget.setRowCount(rowCount + 1)
self.tasksTableWidget.setItem(rowCount, 0,
QTableWidgetItem(task))
self.tasksTableWidget.resizeRowsToContents()
self.taskTextEdit.clear()
def deleteTask(self):
selectedIndexes = self.tasksTableWidget.selectedIndexes()
if selectedIndexes:
self.tasksTableWidget.removeRow(selectedIndexes[0].row())
def markTaskAsFinished(self, row, col):
item = self.tasksTableWidget.item(row, col)
font = self.tasksTableWidget.item(row, col).font()
font.setStrikeOut(False if item.font().strikeOut() else True)
item.setFont(font)
def displayTime(self):
self.timeDisplay.display(self.time.toString(self.timeFormat))
self.statisticsRestTimeDisplay.display(
self.restTime.toString(self.timeFormat))
self.statisticsWorkTimeDisplay.display(
self.workTime.toString(self.timeFormat))
self.statisticsTotalTimeDisplay.display(
self.totalTime.toString(self.timeFormat))
def showWindowMessage(self, status):
if status is Status.workFinished:
self.trayIcon.showMessage("Break", choice(work_finished_phrases),
makeIcon("tomato"))
elif status is Status.restFinished:
self.trayIcon.showMessage("Work", choice(rest_finished_phrases),
makeIcon("tomato"))
else:
self.trayIcon.showMessage("Finished",
choice(pomodoro_finished_phrases),
makeIcon("tomato"))
self.resetButton.click()
def makeButton(self, text, iconName=None, disabled=True):
button = QPushButton(text, sizePolicy=self.size_policy)
if iconName:
button.setIcon(makeIcon(iconName))
button.setDisabled(disabled)
return button
def exit(self):
self.close()
app = QApplication.instance()
if app:
app.quit()
def onActivate(self, reason):
if reason == QSystemTrayIcon.Trigger:
self.show()
class MyMainWindow(QMainWindow, Ui_AudioTool):
def __init__(self, parent=None, backend=None, convolutioner=None):
super(MyMainWindow, self).__init__(parent)
self.setupUi(self)
self.backend = backend
self.backend.finished.connect(self.fin)
self.backend.track_done.connect(self.progress_count)
self.media_player = convolutioner
self.media_player.custom_processing_callback(self.audio_callback)
self.working = False
self.audio_available = False
self.playing = False
self.old_preview = None
self.synthesis_stage = True
""" Hide samples """
self.progress_bar.hide()
self.track_0.hide()
self.effect_0.hide()
self.root = ''
""" Set up sintesis enviroment """
self.track_manager = []
self.instrument_panel = InstrumentsPopUp()
self.select_file.clicked.connect(self.open_midi)
self.sintetizar.clicked.connect(self.create_tracks)
self.sintetizar.setDisabled(True) # No synthesis whitout midi
self.available_to_play = []
""" Media player buttons """
self.media_buttons_widget.play.clicked.connect(self.play)
self.media_buttons_widget.stop.clicked.connect(self.stop)
""" Effects enviroment """
self.working_tracks = [] # To store on working EditedTrackWidget
self.current_track = -1
self.old_effect_prop = []
self.current_effects_properties = []
self.choose_effect.addItem('')
self.effects = []
for i in Effects:
self.effects.append(i.value)
self.choose_effect.addItem(i.value[0])
self.choose_effect.currentIndexChanged.connect(self.renew_effect)
self.to_song.clicked.connect(self.effect_to_song)
self.discard_effect.clicked.connect(self.clean_current_effect)
self.disable_effect_enviroment()
""" Reproduction thing """
self.all_tracks = []
self.all_callbacks = []
self.eddited_song = []
""" Timer things """
self.inner_timer = QTimer()
self.inner_timer.timeout.connect(self.count_down_callback)
self.song_time = QTime()
""" Spectrogram things """
self.spectrogrammer = Spectrogrammer()
self.plot_work.clicked.connect(self.sepectro_plot)
self.prev_plot = None
self.prev_nav = None
""" Notes """
for i in Instruments:
self.note_instrument.addItem(i.value[0])
self.note_add.clicked.connect(self.add_note)
self.note_play.clicked.connect(self.play_notes)
self.all_notes = []
self.save.clicked.connect(self.save_wav)
def save_wav(self):
to_save = None
if self.audio_available:
to_save = self.media_player.output_array.copy()
else:
sum = np.sum(self.all_tracks, axis=0)
max = np.max(sum)
if max != 0:
to_save = sum / max
else:
to_save = sum
file = self.root + '.wav'
write(file, 44100, np.int16(to_save * 32767))
def play_notes(self):
notas = []
for i in self.all_notes:
i, l, v, ins, f = i.get_data()
notas.append(note(i, l, v, ins, f))
self.backend.create_chord(notas)
def add_note(self):
init = self.note_time.value()
long = self.note_duration.value()
velocity = self.note_volume.value()
instrument = self.note_instrument.currentText()
freq = self.note_freq.value()
note = NoteWidget(freq, instrument, velocity, init, long, self)
note.delete.connect(functools.partial(self.remove_note, note))
self.all_notes.append(note)
self.note_area.layout().addWidget(note)
def remove_note(self, note: NoteWidget):
self.all_notes.remove(note)
note.close()
def sepectro_plot(self):
source = self.plot_track.currentText()
data = []
if source == '':
""" Incomplete """
return
elif source == 'Plain Song':
data = np.sum(self.all_tracks, axis=0)
elif source == 'Edited Song':
data = np.sum(self.media_player.output_array.copy(), axis=0)
else:
track_num = int(source.split()[-1])
useful_index = self.available_to_play.index(track_num - 1)
data = self.all_tracks[useful_index]
""" Ya tenemos los datos ahora hay que cortar el tramo de tiempo que se quiera """
title = source + ' init: ' + str(self.plot_time.time().minute()) + ':' + str(self.plot_time.time().second()) + \
' + ' + str(self.plot_long.value()) + 's'
init = 44100 * self.plot_time.time().minute(
) * 60 + self.plot_time.time().second()
fin = init + (self.plot_long.value() * 44100)
song = data[init:fin]
time_array = np.arange(init,
init + song.size / 44100.0,
1 / 44100.0,
dtype=song.dtype)
self.spectrogrammer.compute_audio_array(time_array, song)
self.spectrogrammer.calculate_FFTs()
mag = self.spectrogrammer.get_FFTs_magnitude()
time = self.spectrogrammer.get_resampled_time_array()
freq = self.spectrogrammer.get_FFTs_freq()
plotter = PyQtPlotter()
plotter.spectrogram(time, freq, mag, title, f_bottom=20, f_top=20000)
util_canvas = plotter.canvas
if self.prev_plot is not None:
""" remove previous plot """
self.plot_space.removeWidget(self.prev_plot)
i = self.plot_space.addWidget(util_canvas)
self.plot_space.setCurrentIndex(i)
nav = NavegationToolBar(util_canvas, self)
if self.prev_nav is not None:
self.tool_bar.removeWidget(self.prev_nav)
i = self.tool_bar.addWidget(nav)
self.tool_bar.setCurrentIndex(i)
def count_down_callback(self):
if self.media_player.processing():
self.song_time = self.song_time.addSecs(-1)
self.count_down.setText(self.song_time.toString("m:ss"))
else:
self.playing = False
self.plot_track.addItem('Edited Song')
song_len = len(self.all_tracks[0])
song_len = np.ceil(song_len / 44100.0)
self.song_time.setHMS(0, int(song_len / 60.0), int(song_len % 60))
self.count_down.setText(self.song_time.toString("m:ss"))
self.media_player.terminate_processing()
self.eddited_song = self.media_player.output_array.copy()
self.media_player.clear_output()
self.inner_timer.stop()
self.media_buttons_widget.play.toggle()
for i in self.working_tracks:
i.reset()
def disable_effect_enviroment(self):
self.plot_track.clear()
self.working = False
self.audio_available = False
self.old_preview = None
self.synthesis_stage = True
self.media_buttons_widget.play.setDisabled(True)
self.media_buttons_widget.stop.setDisabled(True)
self.to_track.hide()
self.to_song.hide()
self.choose_effect.setDisabled(True)
self.discard_effect.hide()
self.work_track.setText('')
for tracks in self.track_manager: # Closing old midi tracks
tracks.close()
self.track_manager = []
for track_edits in self.working_tracks:
track_edits.close_all(
) # Clean up old work / be careful with convolutioner!!!
def enable_effects(self):
self.synthesis_stage = False
self.media_buttons_widget.play.setDisabled(False)
self.media_buttons_widget.stop.setDisabled(False)
#self.to_track.show()
#self.to_song.show()
def clean_current_effect(self):
""" First change the callback to use, then reapear and to finish clean everything """
track = self.working_tracks[self.current_track].track_num - 1
useful_index = self.available_to_play.index(track)
if useful_index < 0:
print('Fatal ERROR')
self.all_callbacks[useful_index] = self.nothing # Setting new callback
self.track_manager[track].show() # Reapear in tracks
self.work_track.setText("Track ...")
self.choose_effect.setDisabled(True)
self.working_tracks[self.current_track].close_all()
self.working_tracks[self.current_track].close()
self.working_tracks.pop(self.current_track)
self.current_track = -1
def get_back_effect(self, track_number):
who = -1
j = 0
for i in self.working_tracks:
if i.track_num == track_number:
who = j
break
else:
j += 1
if who == self.current_track:
""" Nothing to do """
return
if self.current_track >= 0:
self.working_tracks[self.current_track].go_backstage()
self.choose_effect.setCurrentIndex(0)
self.choose_effect.setDisabled(False)
self.work_track.setText("Track " + str(track_number))
self.discard_effect.show()
self.current_track = who
self.working_tracks[who].show_properties()
def audio_callback(self, sample):
foo = []
for i in range(0, len(sample)):
foo.append((sample[i], self.all_callbacks[i]))
out = np.array(list(map(self.effects_to_apply, foo)))
return out[:, 0], out[:, 1]
def effects_to_apply(self, var):
func = var[1]
return func(var[0])
def effect_to_song(self):
print('hola')
def select_track(self, index):
if not (not self.synthesis_stage and index in self.available_to_play):
""" If synthesis is not ready, effects are not possible """
return
if self.current_track >= 0:
self.working_tracks[self.current_track].go_backstage()
self.choose_effect.setCurrentIndex(0)
self.track_manager[index].hide()
self.choose_effect.setDisabled(False)
self.work_track.setText("Track " + str(index + 1))
self.discard_effect.show()
temp = EditedTrackWidget(self, self.effect_container.layout(),
index + 1)
self.working_tracks.append(temp)
self.working_effects.layout().addWidget(temp)
self.current_track = self.working_tracks.index(temp)
temp.update_effect.connect(
functools.partial(self.audio_procesing, index + 1))
temp.clicked.connect(self.get_back_effect)
"""
plot = PyQtPlotter()
data = self.all_tracks[self.available_to_play.index(index)]
time = np.arange(len(data))/44100.0
plot.x_vs_y(time, data,"Track "+str(index+1))
util_canvas = plot.canvas
if self.prev_wave is not None:
self.waveform.removeWidget(self.prev_wave)
i = self.waveform.addWidget(util_canvas)
self.waveform.setCurrentIndex(i)
"""
def audio_procesing(self, track_num):
index = 0
for i in range(0, len(self.working_tracks)):
if self.working_tracks[i].me(track_num):
index = i
break
index_2 = self.available_to_play.index(track_num - 1)
print(index)
print(self.working_tracks)
self.all_callbacks[index_2] = self.working_tracks[index].get_callback()
def tracks_audio_prcesing(self, state: bool, index: int):
index = index - 1
useful_index = self.available_to_play.index(index)
if useful_index >= 0:
""" Available ones """
if state:
self.all_callbacks[useful_index] = self.mute
else:
self.all_callbacks[useful_index] = self.nothing
def renew_effect(self, index):
layout = self.effect_container.layout()
if index > 0:
self.old_effect_prop = []
efecto = self.effects[index - 1]
propiedades = efecto[1]
for prop, valor in propiedades.items():
my_item = EffectPropertyWidget(self, prop, valor[0][1],
valor[1])
layout.addWidget(my_item)
self.old_effect_prop.append(my_item)
self.working_tracks[self.current_track].set_effect(
efecto[2](), self.old_effect_prop)
def open_midi(self):
layout = self.track_setter.layout()
self.plot_track.clear()
""" Go to find new """
filename, _ = QFileDialog.getOpenFileName(self, 'Open File', '',
'Midi (*.mid)')
""" If no file is selected quit """
if filename == '':
return
self.progress_bar.setValue(0)
""" Clear previous things"""
self.disable_effect_enviroment()
self.root = filename.split('.')[0]
name = filename.split('/')[-1]
self.midi_name.setText(name)
self.backend.load_midi_file(filename)
tracks = self.backend.get_track_list()
for i in range(0, len(tracks)):
aux_track = TrackConfigWidget(self, str(i + 1),
self.instrument_panel)
aux_track.clicked.connect(functools.partial(self.select_track, i))
""" Aca deberia agarrar el doble ckick !!!!"""
self.track_manager.append(aux_track)
layout.addWidget(self.track_manager[i])
# i += 1
self.label.setText(
'Seleccione los instrumentos, y al sintetizar espere a que se pongan verdes los tracks'
)
self.sintetizar.setDisabled(False)
def create_tracks(self):
""" working is a bool to avoid conflicts while synthesizing """
if not self.working:
fin = len(self.track_manager)
""" May be good looking to start a timer and do something meanwhile.. """
self.working = True
absents = []
all_num = []
for i in range(0, fin):
all_num.append(i)
volume, instrument = self.track_manager[i].get_data()
active = True
if volume == 0 or instrument == '':
absents.append(i)
active = False
self.backend.assign_instrument_to_track(
i, instrument, volume / 100.0, active)
if len(absents) == len(self.track_manager):
print('Compilando vacio')
return
for a in self.track_manager: # This may be useful in future
a.setStyleSheet(
'QWidget { border-style: solid; background-color: rgbrgb(81, 76, 149); border-radius: 5px;}'
)
self.available_to_play = list(
set(all_num).difference(set(absents)))
self.progress_bar.setMaximum(len(self.available_to_play))
self.progress_bar.setValue(0)
self.progress_bar.show()
self.backend.start()
def progress_count(self, a):
self.progress_bar.setValue(self.progress_bar.value() + 1)
self.track_manager[a].setStyleSheet(
'QWidget { border-style: solid; background-color: rgb(31, 172, 102); border-radius: 5px;}'
)
def fin(self):
#self.progress_bar.hide()
self.enable_effects()
self.plot_track.addItem('Plain Song')
self.plot_track.addItems(
['Track ' + str(i + 1) for i in self.available_to_play])
self.working = False
all_tracks = []
""" Load tracks """
for i in range(0, len(self.available_to_play)):
song = np.load(path + 'BackEnd/Tracks/' + 'track' + str(i) +
'.npy')
all_tracks.append(song)
self.all_callbacks.append(
self.nothing) # Adding functions with all ones
if self.media_player is not None:
""" Send input to convolutioner """
self.media_player.update_input(np.array(all_tracks),
np.dtype('float32'))
self.all_tracks = all_tracks.copy()
""" Set timer """
song_len = len(all_tracks[0])
song_len = np.ceil(song_len / 44100.0)
self.song_time.setHMS(0, int(song_len / 60.0), int(song_len % 60))
self.count_down.setText(self.song_time.toString("m:ss"))
self.label.setText(
'Ahora puede poner play, haciendo click sobre un track podrá seleccionalo para agregar efectos'
)
def play(self):
if self.media_buttons_widget.stop.isChecked():
self.media_buttons_widget.stop.toggle()
if self.playing:
self.media_player.terminate_processing()
self.media_player.clear_output()
song_len = len(self.all_tracks[0])
song_len = np.ceil(song_len / 44100.0)
self.song_time.setHMS(0, int(song_len / 60.0), int(song_len % 60))
self.count_down.setText(self.song_time.toString("m:ss"))
self.inner_timer.stop()
for i in self.working_tracks:
i.reset()
self.playing = True
self.media_player.start_non_blocking_processing()
self.inner_timer.start(1000)
def stop(self):
if self.media_buttons_widget.play.isChecked():
self.media_buttons_widget.play.toggle()
if not self.playing:
return
self.playing = False
self.media_player.terminate_processing()
self.media_player.clear_output()
song_len = len(self.all_tracks[0])
song_len = np.ceil(song_len / 44100.0)
self.song_time.setHMS(0, int(song_len / 60.0), int(song_len % 60))
self.count_down.setText(self.song_time.toString("m:ss"))
self.inner_timer.stop()
for i in self.working_tracks:
i.reset()
def preview_adjust(self, track_number):
if self.old_preview is not None:
if self.old_preview != track_number:
""" Clear previous select """
self.track_manager[self.old_preview].setStyleSheet(
'QWidget { border-style: solid; background-color: rgb(81, 76, 149); border-radius: 5px;}'
)
self.track_manager[self.old_preview].preview.toggle()
""" Mark new track"""
self.track_manager[track_number].setStyleSheet(
'QWidget { border-style: solid; background-color: rgb(31, 172, 102); border-radius: 5px;}'
)
self.old_preview = track_number
else:
""" Unselect track """
self.track_manager[self.old_preview].setStyleSheet(
'QWidget { border-style: solid; background-color: rgb(81, 76, 149); border-radius: 5px;}'
)
self.old_preview = None
else:
self.track_manager[track_number].setStyleSheet(
'QWidget { border-style: solid; background-color: rgb(31, 172, 102); border-radius: 5px;}'
)
self.old_preview = track_number
@staticmethod
def nothing(sample):
""" All deltas response, for no effect output """
return (sample, sample)
@staticmethod
def mute(sample):
""" All deltas response, for no effect output """
out = np.array([np.zeros(len(sample))])
return (out, out)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
# Set window properties.
self.setWindowTitle("Speed Typer")
self.my_font = QFont("Helvetica [Cronyx]", 20, QFont.Bold)
self.my_style = "color: rgb(255, 215, 0)"
self.create_widgets()
self.setGeometry(200, 200, 1000, 500)
# Window color.
self.p = self.palette()
self.p.setColor(self.backgroundRole(), QtCore.Qt.black)
self.setPalette(self.p)
# Random sentence from dictionary.
self.sentence = ""
def create_widgets(self):
"""
Method: Intialize all UI widgets.
"""
# Button to generate sentence from dictionary.
self.getSent = QPushButton("Start", self)
self.getSent.setGeometry(440, 20, 100, 45)
self.getSent.clicked.connect(self.generate_S)
self.getSent.setFont(self.my_font)
# Button to close application.
self.closeBtn = QPushButton("Quit", self)
self.closeBtn.setGeometry(440, 300, 100, 45)
self.closeBtn.clicked.connect(self.close)
self.closeBtn.setFont(self.my_font)
# User attempt to type sentence.
self.usrAttempt = QLineEdit(self)
self.usrAttempt.setGeometry(180, 175, 600, 30)
self.usrAttempt.returnPressed.connect(self.fireTimer)
# Submit user attempt.
self.subBtn = QPushButton("submit", self)
self.subBtn.setGeometry(780, 170, 100, 45)
self.subBtn.clicked.connect(self.getAccuracy)
self.subBtn.setFont(self.my_font)
# Label to show random sentence.
self.sentLabel = QLabel("", self)
self.sentLabel.setGeometry(140, 120, 800, 50)
self.sentLabel.setFont(self.my_font)
self.sentLabel.setStyleSheet(self.my_style)
self.disclaimer = QLabel(
"Once you press start, you will display a sentence and be timed. Be ready!",
self)
self.disclaimer.setGeometry(140, 60, 700, 50)
self.disclaimer.setFont(self.my_font)
self.disclaimer.setStyleSheet(self.my_style)
# Labels to show accuracy and time results.
self.accLabel = QLabel("", self)
self.accLabel.setGeometry(250, 200, 200, 50)
self.accLabel.setFont(self.my_font)
self.accLabel.setStyleSheet(self.my_style)
self.timerLabel = QLabel("", self)
self.timerLabel.setGeometry(500, 200, 200, 50)
self.timerLabel.setFont(self.my_font)
self.timerLabel.setStyleSheet(self.my_style)
# Timer object to record time it took for user to type.
self.curr_time = QTime(00, 00, 00)
self.timer = QTimer()
self.timer.setInterval(1000)
self.timer.timeout.connect(self.fireTimer)
def generate_S(self):
"""
Method: Get random sentence from dictionary.
"""
self.disclaimer.hide()
self.accLabel.hide()
self.timerLabel.hide()
self.timer.start()
self.sentence = sentences[random.randrange(0, len(sentences) - 1)]
self.sentence = self.sentence.rstrip()
self.sentLabel.setText(self.sentence)
self.usrAttempt.setText("")
def getAccuracy(self):
"""
Method: Get user's attempt from UI and compute accuracy.
"""
self.timer.stop()
attempt = self.usrAttempt.text()
# Compute string comparison accuracy with SequenceMatcher func from difflib library.
acc = difflib.SequenceMatcher(None, attempt, self.sentence)
result = acc.ratio() * 100
result = str(round(result, 2))
# Update result labels.
self.accLabel.setText(f'Accuracy: {result}%')
self.timerLabel.setText(f'Time: {self.curr_time.toString("hh:mm:ss")}')
self.accLabel.show()
self.timerLabel.show()
# Reset time for label and reset value for user-attempt line edit.
self.curr_time.setHMS(00, 00, 00)
def fireTimer(self):
"""
Method: Fire timer when user starts typing.
"""
self.curr_time = self.curr_time.addSecs(1)
class LiveTab(QMainWindow):
def __init__(self, *args, **kwargs):
super(LiveTab, self).__init__(*args, **kwargs)
uic.loadUi(os.path.join(sys.path[0], 'UI/MainWindow.ui'), self)
# self.ViewGraph.setEnabled(False) # Enabled when there is enough data
self.setFocus()
self.gameTime = QTime(0, 0, 0)
self.redData = list()
self.blueData = list()
self.StartGame.clicked.connect(self.startGame)
self.ViewGraph.clicked.connect(self.showGraph)
self.badStyle = f'background:{badColor}; padding: 5px;'
self.goodStyle = f'background:{highlightColor}; padding: 5px;'
# Status monitors for website statuses, None means 'Loading...'
self.streamUp = None
self.teams = None
self.statsUp = None
self.graphWindow = None # Defined early so we have a reference if never created
self.gameOver = False # Stop data from being collected
self.accurateSides = None # Keeps track if teams have swapped sides during a series
# Create and run the selenium browser to gather data every second about the status and stats
self.browserThread = BrowserThread(self)
self.browserThread.start()
def setStreamStatus(self, status):
if self.streamUp == status:
return
self.streamUp = status
if status:
self.StreamStatusLabel.setText('LIVE')
self.StreamStatusLabel.setStyleSheet(self.goodStyle)
else:
self.StreamStatusLabel.setText('Not Available')
self.StreamStatusLabel.setStyleSheet(self.badStyle)
def setTeams(self, teamList, blueTeam=None, redTeam=None):
self.blueTeam = blueTeam
self.redTeam = redTeam
if self.teams == teamList:
return
self.teams = teamList
if len(teamList) > 0:
self.GameStatusLabel.setText(f'{teamList[0]} vs {teamList[1]}')
self.GameStatusLabel.setStyleSheet(self.goodStyle)
else:
self.GameStatusLabel.setText('No Games Available')
self.GameStatusLabel.setStyleSheet(self.badStyle)
self.teams = teamList
def setDataShown(self, dataShown):
if dataShown is self.statsUp:
return
self.statsUp = dataShown
if dataShown:
self.StatsStatusLabel.setText('Stats Recording')
self.StatsStatusLabel.setStyleSheet(self.goodStyle)
else:
self.StatsStatusLabel.setText('No Stats Available')
self.StatsStatusLabel.setStyleSheet(self.badStyle)
self.dataShown = dataShown
def addData(self, red, blue):
# Add data and increase the game clock unless the game is over
if self.gameOver:
return
self.redData.append(red)
self.blueData.append(blue)
self.updateTime(1)
if len(self.blueData) > 3:
self.ViewGraph.setEnabled(True)
def showStats(self, x):
print(f'showing stats: {x}')
def showGraph(self):
print('showing graph')
self.graphWindow = GraphWindow(self)
self.graphWindow.show()
self.ViewGraph.setEnabled(False)
def saveGraph(self):
print('saving graph')
def updateTime(self, changeAmt=0):
self.gameTime = self.gameTime.addSecs(changeAmt)
def endGame(self):
# Prevent data from being colleted
self.gameOver = True
self.StartGame.setEnabled(True)
def startGame(self):
# Clears the data and allows data to be collected again
self.gameOver = False
self.StartGame.setEnabled(False)
self.redData = list()
self.blueData = list()
def closeEvent(self, *args, **kwargs):
super(LiveTab, self).closeEvent(*args, **kwargs)
try:
self.graphWindow.close()
except Exception:
pass # The window failed to close because it was already closed
self.browserThread.closeBrowser()
self.browserThread.quit()
class Game(QMainWindow, Ui_GameWindow):
def __init__(self):
super().__init__()
super().setupUi(self)
self.setFixedSize(500, 400)
# внетренняя переменная сколько сек живет кнопка
self.t = TIME_OUT
self.timer = QTimer()
self.time = QTime(0, 0, self.t)
# кнопка-бегунок
self.runner.hide()
# переменная сложности для размера кнопки-бегунка
self.d = SIZE_OF_RUNNER * LEVELS[0][1]
self.runner.resize(self.d, self.d)
# таймер в окне
self.label.setText('00:20')
# сообзщение перед запуском
# message = QInputDialog.getItem(self, 'Сообщение', 'Обязательно посмотрите раздел О программе', 'OK', 0, False)
self.initUi()
# свои настройки
self.man_set = Man_Set()
self.is_dark = False
def initUi(self):
# просто случайный смайл в статусбаре ¯\(⌒‿⌒)/¯
self.statusBar().showMessage(choice(SMLS))
# кнопка старта
self.beginbtn.clicked.connect(self.run)
# меню сложности
self.Menu_Difficulty.triggered.connect(self.Difficulty)
# меню своих настроек
self.Manual_Settings.triggered.connect(self.Man_Set)
# меню справки
self.About_program.triggered.connect(self.About)
# темная тема
self.dark.clicked.connect(self.dark_phone)
# TODO: -----
def dark_phone(self):
if not self.is_dark:
self.is_dark = True
self.setStyleSheet('background-color: black')
self.beginbtn.setStyleSheet('background-color: gray')
self.label.setStyleSheet('background-color: gray')
self.dark.setStyleSheet('background-color: gray')
else:
self.is_dark = False
self.beginbtn.setStyleSheet('background-color: white')
self.label.setStyleSheet('background-color: white')
self.dark.setStyleSheet('background-color: white')
self.setStyleSheet('background-color: white')
if not col:
self.runner.setStyleSheet('background-color: grey')
# злополучный таймер, там же применение своих настроек
def run(self):
print('run timer')
# свои настройки
self.run_color()
self.timer = QTimer()
self.time = QTime(0, 0, self.t)
self.timer.start(1000)
self.timer.timeout.connect(self.timerEvent)
# события связанные с таймером
def timerEvent(self):
print(self.t)
# меняет время в окне в QLabel
self.label.setText(self.time.toString("mm:ss"))
# таймер до 0
if self.time != QTime(0, 0, 0):
print('!')
self.runner.show()
self.beginbtn.hide()
self.runner.clicked.connect(self.change_pos)
self.time = self.time.addSecs(-1)
else:
print('else')
self.runner.hide()
self.beginbtn.show()
self.label.setText('00:20')
self.timer.stop()
# проблемный метод изменения позиции "бегуна", меняет столько раз, сколько прошло секунд... (не знаю как исправить)
def change_pos(self):
# случайный цвет
if col == 'rm_col':
self.runner.setStyleSheet(
"background-color: rgb({}, {}, {})".format(
randint(0, 255), randint(0, 255), randint(0, 255)))
# красный цвет
elif col == 'red_col':
self.runner.setStyleSheet("background-color: red")
# зеленый цвет
elif col == 'green_col':
self.runner.setStyleSheet("background-color: green")
# синий цвет
elif col == 'blue_col':
self.runner.setStyleSheet("background-color: blue")
self.runner.move(randint(100,
self.width() - 200),
randint(100,
self.height() - 200))
self.runner.repaint()
# метод вызывающий окно выбора сложности
def Difficulty(self):
diff, okBtnPressed = QInputDialog.getItem(
self, "Difficulty", 'Выберите сложность, с которой хотите играть.',
('easy', 'normal', 'hard'), 0, False)
# постановка сложности
if okBtnPressed:
if diff == 'easy':
self.d = SIZE_OF_RUNNER * LEVELS[0][1]
elif diff == 'normal':
self.d = SIZE_OF_RUNNER * LEVELS[1][1]
elif diff == 'hard':
self.d = SIZE_OF_RUNNER * LEVELS[2][1]
self.runner.resize(self.d, self.d)
# метод окна своих настроек
def Man_Set(self):
print('Man_Set')
self.man_set.setFixedSize(400, 300)
self.man_set.show()
# осуществление своих настроек
def run_color(self):
# случайный цвет
if col == 'rm_col':
self.runner.setStyleSheet(
"background-color: rgb({}, {}, {})".format(
randint(0, 255), randint(0, 255), randint(0, 255)))
# красный цвет
elif col == 'red_col':
self.runner.setStyleSheet("background-color: red")
# зеленый цвет
elif col == 'green_col':
self.runner.setStyleSheet("background-color: green")
# синий цвет
elif col == 'blue_col':
self.runner.setStyleSheet("background-color: blue")
# выбрать цвет самостоятельно
elif col == 'manual_col':
color = QColorDialog.getColor()
if color.isValid():
self.runner.setStyleSheet("background-color: {}".format(
color.name()))
# метод окна справки
def About(self):
QInputDialog.getItem(
self, 'About',
'Эта программа создана для проверки и улучшения реакции.\nЕсть несколько '
'режимов сложности, они влияют на размер\nкнопки.\nЕще можно менять цвет в своих '
'настройках, обязательно\nзагляните туда!\nЖелаю хорошо провести время!\n'
'---------------------------------------------------------------------------------------\n'
'И кстати, пожалуйста, перезапускайте программу хотябы через каждые 5 стартов.\n'
'---------------------------------------------------------------------------------------\n',
('ок', 'хорошо', 'нормально', 'спасибо))0)00))0)))'), 3, False)
# Метод кнопочек
def keyPressEvent(self, event):
# Esc >> exit
if event.key() == Qt.Key_Escape:
self.close()
# Метод вызывающий окно с подтверждением выхода
def closeEvent(self, event):
res = QMessageBox.question(self, "Confirm exit",
"Are you sure you want to exit?",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if res == QMessageBox.Yes:
event.accept()
else:
event.ignore()
class MainWindow(QWidget):
def __init__(self):
super().__init__()
self.backlog = Backlog()
self.backlog.load(
"C:\\Users\\Patrick\\Documents\\Python\\Giro\\turboClock\\Data\\tasksData.dat"
)
self.currTask = Task()
self.currPiece = Piece()
self.currDuty = Duty()
self.currTaskItemRow = 0
self.isTimerRunning = False
self.editTasksGUI = EditBacklogGUI(self, self.backlog)
self.initUI()
def initUI(self):
self.setWindowTitle("TurboClock")
self.resize(400, 300)
self.setWindowIcon(QIcon('Images//clock.png'))
self.icon = QSystemTrayIcon(self)
self.icon.setIcon(QIcon('Images//clock.png'))
self.icon.setVisible(True)
self.lcdNumber = QLCDNumber()
self.lcdNumber.setNumDigits(8)
self.btnStartPause = QPushButton('', self)
self.btnStartPause.setIcon(QIcon('Images//play_icon.png'))
self.btnStartPause.clicked.connect(self.manageStartPauseClickButton)
self.btnDutyDetails = QPushButton('Duty details...')
self.btnDutyDetails.clicked.connect(self.manageDutyDetailsClickedEvent)
self.btnAddTfsTask = QPushButton('', self)
self.btnAddTfsTask.setIcon(QIcon('Images//plus_icon.png'))
self.btnAddTfsTask.clicked.connect(self.manageEditTasksOptions)
self.progressBar = QProgressBar()
self.progressBar.setValue(0)
self.dutyTimeCompLbl = QLabel()
self.taskCb = QComboBox(self)
self.initTaskCombobox()
mainLayout = QVBoxLayout(self)
layoutTimer = QVBoxLayout()
layoutTimer.addWidget(self.lcdNumber)
fieldsInputLayout = QHBoxLayout()
layoutInputCodes = QVBoxLayout()
layoutInputCodes.addWidget(self.taskCb)
layoutAddBtn = QVBoxLayout()
layoutAddBtn.addWidget(self.btnAddTfsTask)
fieldsInputLayout.addLayout(layoutInputCodes)
fieldsInputLayout.addLayout(layoutAddBtn)
layoutDutyStat = QHBoxLayout()
layoutDutyStat.addWidget(self.dutyTimeCompLbl)
layoutProgressBar = QHBoxLayout()
layoutProgressBar.addWidget(self.progressBar)
mainLayout.addLayout(layoutTimer)
mainLayout.addLayout(fieldsInputLayout)
mainLayout.addWidget(self.btnStartPause)
mainLayout.addWidget(self.btnDutyDetails)
mainLayout.addWidget(self.progressBar)
mainLayout.addLayout(layoutDutyStat)
self.timer = QTimer(self)
self.deltaTimer = 0
self.currTimeLCD = QTime(0, 0, 0)
self.currTimeDuty = QTime(0, 0, 0)
self.timer.timeout.connect(self.incrementTimer)
self.updateTimeLCD()
self.updateDutyTimeDisp()
self.updateProgressBarDisplay()
def initTaskCombobox(self):
self.updateTaskCombobox()
self.taskCb.currentIndexChanged.connect(self.manageCbIndexChange)
def updateProgressBarDisplay(self):
estimatedTime = self.currTask.estimatedTime
if estimatedTime == 0:
return
ratioFromTimer = (self.deltaTimer / estimatedTime)
totalCompletionPerc = int(
(self.currTask.completionRatio + ratioFromTimer) * 100)
if totalCompletionPerc <= 100:
self.progressBar.setValue(totalCompletionPerc)
else:
self.progressBar.setValue(100)
def updateTaskCombobox(self):
currTaskIndex = 0
self.taskCb.clear()
tasks = self.backlog.tasks
for currTask in tasks:
taskDesc = currTask.title + ' - ' + currTask.prjCode
self.taskCb.addItem(taskDesc)
self.taskCb.setCurrentIndex(currTaskIndex)
self.manageSelectedTaskChange(self.taskCb.currentText())
def manageCbIndexChange(self):
self.currTaskItemRow = self.taskCb.currentIndex()
if self.currTaskItemRow >= 0 and self.currTaskItemRow <= self.taskCb.count(
):
currTextCb = self.taskCb.currentText()
self.manageSelectedTaskChange(currTextCb)
self.updateTimeLCD()
self.deltaTimer = 0
self.updateProgressBarDisplay()
def updateTimeLCD(self):
currTaskTimeStr = str(
datetime.timedelta(seconds=self.currTask.completedTime))
currTaskTime_split = str(currTaskTimeStr).split(':')
h = int(currTaskTime_split[0])
m = int(currTaskTime_split[1])
s = int(currTaskTime_split[2])
self.currTimeLCD = QTime(h, m, s)
self.lcdNumber.display(self.currTimeLCD.toString('hh:mm:ss'))
def updateDutyTimeDisp(self):
currDutyTimeStr = str(
datetime.timedelta(seconds=self.currDuty.totalTimeCompleted))
currDutyTime_split = currDutyTimeStr.split(':')
h = int(currDutyTime_split[0])
m = int(currDutyTime_split[1])
s = int(currDutyTime_split[2])
self.currTimeDuty = QTime(h, m, s)
self.dutyTimeCompLbl.setText('Daily time completed: ' +
self.currTimeDuty.toString('hh:mm:ss'))
def incrementTimer(self):
self.currTimeLCD = self.currTimeLCD.addSecs(1)
self.lcdNumber.display(self.currTimeLCD.toString('hh:mm:ss'))
self.currTimeDuty = self.currTimeDuty.addSecs(1)
self.dutyTimeCompLbl.setText('Daily time completed: ' +
self.currTimeDuty.toString('hh:mm:ss'))
self.deltaTimer += 1
self.updateProgressBarDisplay()
def manageSelectedTaskChange(self, iCbbText):
splitCurrTextCb = iCbbText.split(' - ')
title = splitCurrTextCb[0]
prjCode = splitCurrTextCb[1]
indexBacklogCurrTask = self.backlog.getIndexFromTask(
Task(prjCode, title))
if indexBacklogCurrTask != None:
if self.isTimerRunning:
self.endPiece()
self.startPiece()
self.currTask = self.backlog.tasks[indexBacklogCurrTask]
else:
return
def startPiece(self):
self.currPiece = Piece(self.currTask, datetime.datetime.now())
self.isTimerRunning = True
def endPiece(self):
self.currPiece.setEndDateTime(datetime.datetime.now())
self.currDuty.addPiece(self.currPiece)
self.currTask.addCompletedTime(self.currPiece.task.completedTime)
self.isTimerRunning = False
def manageStartPauseClickButton(self):
if self.currTask:
self.deltaTimer = 0
if self.isTimerRunning:
self.timer.stop()
self.endPiece()
self.btnStartPause.setIcon(QIcon('Images//play_icon.png'))
else:
self.timer.start(1000)
self.startPiece()
self.btnStartPause.setIcon(QIcon('Images//pause_icon.png'))
def manageDutyDetailsClickedEvent(self):
pass
def manageEditTasksOptions(self):
self.editTasksGUI.exec_()
class IntervalTimerGui(QMainWindow):
def __init__(self):
super(QMainWindow, self).__init__()
self.counter = 0
self.time_left = DURATION
self.time = QTime(0, 0, 0) # h m s ms
self.setup_UI()
def setup_UI(self):
wid = QWidget()
self.time = self.time.addSecs(self.time_left)
self.time_label = QLabel(self.time.toString())
self.time_descr_label = QLabel("Time")
self.counter_descr_label = QLabel("Counter:")
self.counter_label = QLabel(str(self.counter))
self.start_stop_btn = QPushButton("Start")
self.start_stop_btn.clicked.connect(self.pressed_start)
self.done_btn = QPushButton("Done")
self.done_btn.setEnabled(False)
self.done_btn.clicked.connect(self.pressed_done)
hbox_1 = QHBoxLayout()
hbox_1.addWidget(self.time_descr_label)
hbox_1.addWidget(self.time_label)
hbox_1.addWidget(self.start_stop_btn)
hbox_2 = QHBoxLayout()
hbox_2.addWidget(self.counter_descr_label)
hbox_2.addWidget(self.counter_label)
hbox_2.addWidget(self.done_btn)
vbox = QVBoxLayout()
vbox.addLayout(hbox_1)
vbox.addLayout(hbox_2)
wid.setLayout(vbox)
self.setCentralWidget(wid)
title = "Interval Timer"
self.setWindowTitle(title)
def pressed_start(self):
self.start_stop_btn.disconnect()
self.start_stop_btn.setText("Stop")
self.start_stop_btn.clicked.connect(self.pressed_stop)
self.count_down()
def pressed_stop(self):
self.start_stop_btn.disconnect()
self.start_stop_btn.setText("Start")
self.start_stop_btn.clicked.connect(self.pressed_start)
self.worker.stop()
def pressed_done(self):
self.done_btn.setEnabled(False)
self.counter += 1
self.counter_label.setText(str(self.counter))
self.start_stop_btn.setEnabled(True)
self.pressed_stop()
self.reset_timer()
def reset_timer(self):
self.time = QTime(0, 0, 0)
self.time_left = DURATION
self.time = self.time.addSecs(self.time_left)
self.time_label.setText(self.time.toString())
def update_time_label(self):
self.time_left -= 1
self.time = self.time.addSecs(-1)
self.time_label.setText(self.time.toString())
def count_down(self):
self.worker = CountdownThread(self.time_left)
self.worker.time_signal.update.connect(self.update_time_label)
self.worker.time_signal.stop.connect(self.reset_timer)
self.worker.time_signal.finished.connect(self.alarm)
self.worker.start()
def alarm(self):
self.done_btn.setEnabled(True)
self.start_stop_btn.setEnabled(False)
Thread(target=self.play_sound).start()
self.show_dialog()
def show_dialog(self):
dialog = QDialog()
dialog.setWindowTitle = "Time for your reps!"
dialog_label = QLabel("Timer abgelaufen!", dialog)
dialog_button = QPushButton("Ok", dialog)
dialog_button.clicked.connect(dialog.accept)
vbox = QVBoxLayout(dialog)
vbox.addWidget(dialog_label)
vbox.addWidget(dialog_button)
dialog.setLayout(vbox)
dialog.exec()
def play_sound(self):
playsound('src/media/shen.mp3')
class DialogoCargando(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.dibujar_IU()
def dibujar_IU(self):
self.setWindowTitle("Calculando...")
self.setWindowModality(Qt.ApplicationModal)
self.setSizeGripEnabled(False)
self.setContentsMargins(10, 10, 10, 10)
self.setFixedSize(QSize(500, 300))
self.animacion = AnimacionCargando()
self.texto_informativo = QLabel("")
self.texto_informativo.setAlignment(Qt.AlignCenter)
self.texto_informativo.setWordWrap(True)
self.texto_tiempo = QLabel("00:00:00")
self.texto_tiempo.setAlignment(Qt.AlignCenter)
self.texto_tiempo.setWordWrap(True)
self.caja_horizontal = QHBoxLayout()
self.caja_horizontal.addStretch(1)
self.caja_horizontal.addWidget(self.animacion)
self.caja_horizontal.addStretch(1)
self.caja = QVBoxLayout()
self.caja.setAlignment(Qt.AlignCenter)
self.caja.addStretch(4)
self.caja.addWidget(self.texto_informativo)
self.caja.addStretch(1)
self.caja.addLayout(self.caja_horizontal)
self.caja.addWidget(self.texto_tiempo)
self.caja.addStretch(2)
grupo = QGroupBox()
grupo.setLayout(self.caja)
hola = QVBoxLayout()
hola.addWidget(grupo)
self.setLayout(hola)
self.reloj = QTime(0, 0, 0, 0)
self.timer = QTimer(self)
self.timer.timeout.connect(self.actualizar_reloj)
self.timer.start(1000)
self.boton_confirmar = QPushButton(QIcon("iconos/right-arrow.png"), "",
self)
self.boton_confirmar.clicked.connect(self.accept)
self.boton_confirmar.setDefault(True)
self.boton_confirmar.setMinimumSize(50, 22)
self.boton_confirmar.setMaximumSize(50, 22)
self.boton_confirmar.setVisible(False)
self.boton_confirmar.move(400, 240)
def setear_texto(self, texto):
self.texto_informativo.setText(texto)
def actualizar_reloj(self):
self.reloj = self.reloj.addSecs(1)
self.texto_tiempo.setText(self.reloj.toString("hh:mm:ss"))
def mostrar_boton_confirmar(self):
self.texto_tiempo.setVisible(False)
self.animacion.setVisible(False)
self.setear_texto(
"Proceso terminado exitosamente en {0}\nA continuación podrá consultar los resultados finales"
.format(self.reloj.toString("hh:mm:ss")))
self.boton_confirmar.setVisible(True)
#Es para evitar que se cierre el Dilog con la tecla ESC
def reject(self):
self.close()
def closeEvent(self, event):
event.ignore()
class DroneGUI(QDialog):
global l, w
def __init__(self, parent=None):
super(DroneGUI, self).__init__(parent)
# creates the terminal
self.create_terminal()
# create tabs
self.create_tabs()
# set the size policy
self.set_size_policy()
# palette background setting, style
self.create_palette()
# adds the arm, kill, unarm buttons
# self.create_arm_kill_buttons()
# adds the PID insert text boxes
self.create_PID_insert()
# adds the log
self.create_log()
# stream for the command line output to fill the log
sys.stdout = Stream(newText=self.onUpdateText)
# adds the data monitor
self.create_data_monitor()
# installs the event filter for 'space bar' and 'a'
qApp.installEventFilter(self)
# creates a button to deliver a live motor output plot graph
self.motor_output_plot_graph_is_open = False
self.create_motor_output_plot_button()
# create the flight motion labels
self.create_flight_motion_labels()
# shows the current information of the drone
self.drone_information()
# add logo
self.set_logo()
# set up about tab
self.show_about_info()
# commands currently allowed in the terminal
self.accepted_commands = {"connect", "arm", "kill", "forward",
"altitude", "vehicle status", "pi status", "square"}
# accepted IPs for the Raspberry Pi
self.accepted_ips = {"192.168.1.1"}
self.ssh_client = None
def eventFilter(self, obj, event):
if event.type() == QEvent.KeyPress:
if event.key() == Qt.Key_Return:
x = self.term.toPlainText().strip()
split = x.split(' ')
if split[0] in self.accepted_commands:
if split[0] == "connect":
if len(split) > 1:
if split[1] in self.accepted_ips:
print("> Connecting RPi...")
print("=> " + split[1])
self.ssh_client = self.connect_to_pi(split[1], 22, 'admin')
elif split[0] == "arm":
print("> Arming...")
# self.executeCommand(self.ssh_client, 'python ./RPi_FC.py')
self.term.clear()
return super(DroneGUI, self).eventFilter(obj, event)
# filters space bar to allow it to be a killswitch only
# filters 'a' to allow it to arm the drone only
#def eventFilter(self, obj, event):
# if event.type() == QEvent.KeyPress:
# if event.key() == Qt.Key_Space:
# if self.arm_button.isChecked():
# print("KILL SWITCH ACTIVATED")
# self.arm_button.toggle()
# self.arm_button.setEnabled(False)
# self.undo_killswitch_button.setEnabled(True)
# self.undo_killswitch_button.setStyleSheet("background-color: yellow; color:black")
# self.arm_button.setStyleSheet("background-color: Gray")
# self.killswitch_button.setEnabled(False)
# self.killswitch_button.setStyleSheet("background-color: Darkred; color:black")
# self.curr_status.setStyleSheet("background-color: #922B3E;")
# self.curr_status.setText("Inactive")
# self.flight_timer.stop()
# # fc.receiver.ARM = False
# return True
# else:
# return True
# if event.key() == Qt.Key_A:
# if not(self.arm_button.isChecked()):
# print()
# print("Initialize Arming Process...")
# self.arm_button.setStyleSheet("background-color: Green")
# self.undo_killswitch_button.setEnabled(False)
# self.killswitch_button.setEnabled(True)
# self.killswitch_button.setStyleSheet("background-color: red")
# self.undo_killswitch_button.setStyleSheet("background-color:rgb(53,53,53);")
# self.arm_button.setEnabled(False)
# self.arm_button.setChecked(True)
# self.curr_status.setStyleSheet("background-color: #507D2A")
# self.curr_status.setText("Active")
# self.flight_timer.start(1000)
# # Since we're skipping the unlock arm button,
# # fc.run()
# return True
# else:
# return True
# return super(DroneGUI, self).eventFilter(obj, event)
# Connects to the IP using a port, username, and password via SSH.
def connect_to_pi(self, ip, port, username, password="******"):
sshClient = paramiko.SSHClient()
sshClient.set_missing_host_key_policy(paramiko.AutoAddPolicy())
sshClient.load_system_host_keys()
try:
sshClient.connect(ip, port, username, password, timeout=10)
except Exception as e:
print(e)
sshClient.connect(ip + ".local", port, username, password)
return sshClient
# Takes in an sshClient and sends the command to it
def executeCommand(sshClient, command):
stdin, stdout, stderr = sshClient.exec_command(command)
print("> COMMAND:", command)
# creates a log for the command line output
def create_terminal(self):
self.term = QTextEdit(self)
self.term.move(l-260, 20)
self.term.setFixedSize(260,22)
self.term.setFixedHeight(18)
self.term.moveCursor(QTextCursor.Start)
self.term.setReadOnly(False)
self.term.setCursorWidth(4)
# resizes the GUI
def set_size_policy(self):
self.sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.sizePolicy.setHorizontalStretch(0)
self.sizePolicy.setVerticalStretch(0)
self.sizePolicy.setHeightForWidth(self.sizePolicy.hasHeightForWidth())
self.setSizePolicy(self.sizePolicy)
self.setMaximumSize(l, w)
self.setMinimumSize(l, w)
# Creates the tabs
def create_tabs(self):
self.tabWidget = QTabWidget(self)
self.tabWidget.setGeometry(QRect(0, 150, l-260,w-100 ))
self.tabWidget.setMaximumSize(QSize(l, w-100))
self.tabWidget.setTabPosition(QTabWidget.North)
self.tabWidget.setTabShape(QTabWidget.Rounded)
self.tabWidget.setElideMode(Qt.ElideRight)
self.tabWidget.setUsesScrollButtons(False)
self.tabWidget.setDocumentMode(True)
self.tabWidget.setTabsClosable(False)
self.tabWidget.setMovable(False)
self.tabWidget.setTabBarAutoHide(False)
self.data_tab = QWidget()
self.settings_tab = QWidget()
self.flight_pattern_tab = QWidget()
self.about_tab = QWidget()
self.tabWidget.addTab(self.settings_tab, "Settings")
self.tabWidget.addTab(self.data_tab, "Data")
self.tabWidget.addTab(self.flight_pattern_tab, "Flight Pattern")
self.tabWidget.addTab(self.about_tab, "About")
self.tabWidget.show()
# Defines the palette colors
def create_palette(self):
self.setWindowTitle("Flight Controller")
app.setStyle("Fusion")
app.setFont(QFont("Helvetica"))
dark_palette = QPalette()
dark_palette.setColor(QPalette.Window, QColor(53, 53, 53))
dark_palette.setColor(QPalette.WindowText, Qt.white)
dark_palette.setColor(QPalette.Base, QColor(25, 25, 25))
dark_palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ToolTipBase, Qt.white)
dark_palette.setColor(QPalette.ToolTipText, Qt.white)
dark_palette.setColor(QPalette.Text, Qt.white)
dark_palette.setColor(QPalette.Button, QColor(53, 53, 53))
dark_palette.setColor(QPalette.ButtonText, Qt.white)
dark_palette.setColor(QPalette.BrightText, Qt.red)
dark_palette.setColor(QPalette.Link, QColor(42, 130, 218))
dark_palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
dark_palette.setColor(QPalette.HighlightedText, Qt.black)
app.setPalette(dark_palette)
# # create buttons to arm, and kill, and un-kill the drone
# def create_arm_kill_buttons(self):
# # button to arm the drone
# self.arm_button = QPushButton('ARM', self)
# self.arm_button.setDefault(False)
# self.arm_button.setAutoDefault(False)
# self.arm_button.setStyleSheet("background-color: green")
# self.arm_button.move(0, 0)
# self.arm_button.resize(70, 43)
# self.arm_button.setFont(QFont("Helvetica", 17.5))
# self.arm_button.setCheckable(True)
# self.arm_button.setEnabled(True)
# self.arm_button.clicked.connect(self.arm_drone)
# self.arm_button.setShortcut("A")
#
# # button to kill the drone
# self.killswitch_button = QPushButton('KILL SWITCH', self)
# self.killswitch_button.move(l-110, 0)
# self.killswitch_button.setDefault(False)
# self.killswitch_button.setAutoDefault(False)
# self.killswitch_button.setFont(QFont("Helvetica", 17.0))
# self.killswitch_button.resize(110, 60)
# self.killswitch_button.clicked.connect(self.kill_motor)
# self.killswitch_button.setStyleSheet("background-color: red")
# self.killswitch_button.setEnabled(False)
# self.killswitch_button.setShortcut("Space")
#
# # button to undo kill switch
# self.undo_killswitch_button = QPushButton('Unlock ARM', self)
# self.undo_killswitch_button.setDefault(False)
# self.undo_killswitch_button.setAutoDefault(False)
# self.undo_killswitch_button.move(l-110, 62)
# self.undo_killswitch_button.setFont(QFont("Helvetica", 12))
# self.undo_killswitch_button.resize(75, 30)
# self.undo_killswitch_button.clicked.connect(self.undo_killswitch)
# self.undo_killswitch_button.setStyleSheet("background-color:rgb(53,53,53);")
# self.undo_killswitch_button.setEnabled(False)
#
# # button to exit the application
# self.exit_app_button = QPushButton('exit', self)
# self.exit_app_button.resize(0,0)
# self.exit_app_button.setShortcut("Shift+Q")
# self.exit_app_button.clicked.connect(self.exit_application)
# killswitch for the drone
def kill_motor(self):
if self.arm_button.isChecked():
print("KILL SWITCH ACTIVATED")
self.flight_timer.stop()
self.arm_button.toggle()
self.arm_button.setEnabled(False)
self.undo_killswitch_button.setEnabled(True)
self.undo_killswitch_button.setStyleSheet("background-color: yellow; color:black")
self.killswitch_button.setEnabled(False)
self.killswitch_button.setStyleSheet("background-color: Darkred; color:black")
self.arm_button.setStyleSheet("background-color: Gray")
self.curr_status.setStyleSheet("background-color: #922B3E;")
self.curr_status.setText("Inactive")
# fc.receiver.ARM = False
# allows the drone to be armed again
def undo_killswitch(self):
print("Arm button unlocked")
self.arm_button.setEnabled(True)
self.undo_killswitch_button.setEnabled(False)
self.killswitch_button.setStyleSheet("background-color: red")
self.undo_killswitch_button.setStyleSheet("background-color: Gold")
self.arm_button.setStyleSheet("background-color: Green")
# fc.receiver.ARM = True
# arms the drone
def arm_drone(self):
print()
print("Initialize Arming Process...")
self.flight_timer.start(1000)
self.undo_killswitch_button.setEnabled(False)
self.killswitch_button.setEnabled(True)
self.undo_killswitch_button.setStyleSheet("background-color:rgb(53,53,53);")
self.arm_button.setEnabled(False)
self.curr_status.setStyleSheet("background-color: #507D2A")
self.curr_status.setText("Active")
# fc.run()
# displays current drone information
def drone_information(self):
# widget for the drone status section
self.drone_status = QWidget(self.settings_tab)
self.drone_status.resize(180,110)
self.drone_status.move(92,200)
self.state_label = QPushButton("Drone Status", self.drone_status)
self.state_label.setCheckable(False)
self.state_label.setEnabled(False)
self.state_label.setStyleSheet("background: #333332; color: white")
self.state_label.move(0, 0)
self.state_label.show()
self.state_label.resize(80,20)
self.curr_status = QPushButton("Inactive", self.drone_status)
self.curr_status.setIcon(QIcon("Images/Icons/drone.png"))
self.curr_status.setDefault(False)
self.curr_status.setEnabled(False)
self.curr_status.setStyleSheet("background-color: #922B3E;")
self.curr_status.move(81,0)
self.curr_status.resize(70,20)
self.curr_P = QLineEdit(self.drone_status)
self.curr_P.setReadOnly(True)
self.curr_P_label = QLabel(self.drone_status)
self.curr_P_label.move(2, 25)
self.curr_P_label.setText("Proportional:")
self.curr_P_label.show()
self.curr_P.setText(str(fc.Kp)) # " ", str(fc.Ki), " ", str(fc.Kd))
self.curr_P.move(80, 25)
self.curr_P.resize(90,12)
self.curr_P.show()
self.curr_I_label = QLabel(self.drone_status)
self.curr_I_label.move(2, 40)
self.curr_I_label.setText(" Integral:")
self.curr_I_label.show()
self.curr_I = QLineEdit(self.drone_status)
self.curr_I.setReadOnly(True)
self.curr_I.setText(str(fc.Ki)) # " ", str(fc.Ki), " ", str(fc.Kd))
self.curr_I.move(80, 40)
self.curr_I.resize(90,12)
self.curr_I.show()
self.curr_D_label = QLabel(self.drone_status)
self.curr_D_label.move(2, 55)
self.curr_D_label.setText(" Derivative:")
self.curr_D_label.show()
self.curr_D = QLineEdit(self.drone_status)
self.curr_D.setReadOnly(True)
self.curr_D.setText(str(fc.Kd)) # " ", str(fc.Ki), " ", str(fc.Kd))
self.curr_D.move(80, 55)
self.curr_D.resize(90, 12)
self.curr_D.show()
self.flight_time_label = QLabel("Flight Time:", self.drone_status)
self.flight_time_label.move(5, 85)
self.flight_time = QLineEdit(self.drone_status)
self.flight_time.setReadOnly(True)
self.flight_time.move(80, 80)
self.flight_time.setFont(QFont("Helvetica", 15))
self.flight_time.resize(50,18)
self.flight_timer = QTimer()
self.time = QTime(0,0)
self.flight_timer.timeout.connect(self.update_timer)
self.hard_wired_button = QPushButton("Hard Wired Inputs", self.settings_tab)
self.hard_wired_button.move(l-365,2)
self.hard_wired_button.setStyleSheet("background-color:#002366;")
self.hard_wired_button.clicked.connect(self.show_hard_wire_connections)
# gets the current updated PID values
def get_PID_value(self):
# try:
# fc.Kp = np.array([float(self.Kp0_textbox.text()), float(self.Kp1_textbox.text()), float(self.Kp2_textbox.text())])
# fc.Ki = np.array([float(self.Ki0_textbox.text()), float(self.Ki1_textbox.text()), float(self.Ki2_textbox.text())])
# fc.Kd = np.array([float(self.Kd0_textbox.text()), float(self.Kd1_textbox.text()), float(self.Kd2_textbox.text())])
# except(ValueError):
# print("Error: Must input values into each coordinate.")
# else:
# print()
# print(time.strftime(" %H:%M:%S %Z"))
# print("Update PID Gains")
# print("P: ", fc.Kp[0], " ", fc.Kp[1], " ", fc.Kp[2])
# print("I : ", fc.Ki[0], " ", fc.Ki[1], " ", fc.Ki[2])
# print("D: ", fc.Kd[0], " ", fc.Kd[1], " ", fc.Kd[2])
print()
# creates the PID text boxes, button for updating PID values
def create_PID_insert(self):
print()
# widget for PID insertion
# self.PID_widget = QWidget(self.settings_tab)
# self.PID_widget.resize(300,200)
# self.PID_widget.move(10,20)
# # proportional text
# self.onlyDouble = QDoubleValidator()
# self.Kp0_textbox = QLineEdit(self.PID_widget)
# self.Kp0_textbox.clearFocus()
# self.Kp0_textbox.setValidator(self.onlyDouble)
# self.Kp0_textbox.resize(50, 23)
# self.Kp0_textbox.setText(str(fc.Kp[0]))
# self.Kp1_textbox = QLineEdit(self.PID_widget)
# self.Kp1_textbox.setValidator(self.onlyDouble)
# self.Kp1_textbox.resize(50, 23)
# self.Kp1_textbox.move(50,0)
# self.Kp1_textbox.setText(str(fc.Kp[1]))
# self.Kp2_textbox = QLineEdit(self.PID_widget)
# self.Kp2_textbox.setValidator(self.onlyDouble)
# self.Kp2_textbox.resize(50, 23)
# self.Kp2_textbox.move(100, 0)
# self.Kp2_textbox.setText(str(fc.Kp[2]))
# # proportional label
# self.Kp_label = QLabel(self.PID_widget)
# self.Kp_label.setText('Proportional')
# self.Kp_label.move(150, 0)
# self.Kp_label.resize(85, 23)
# self.Kp_label.setFrameShape(QFrame.Panel)
# self.Kp_label.setFrameShadow(QFrame.Sunken)
# self.Kp_label.setLineWidth(3)
# self.Kp_label.setStyleSheet("background-color:rgb(53,53,53);")
#
# # integral text
# self.Ki0_textbox = QLineEdit(self.PID_widget)
# self.Ki0_textbox.move(0, 27)
# self.Ki0_textbox.resize(50, 23)
# self.Ki0_textbox.setValidator(self.onlyDouble)
# self.Ki0_textbox.setText(str(fc.Ki[0]))
# self.Ki1_textbox = QLineEdit(self.PID_widget)
# self.Ki1_textbox.move(50, 27)
# self.Ki1_textbox.resize(50, 23)
# self.Ki1_textbox.setValidator(self.onlyDouble)
# self.Ki1_textbox.setText(str(fc.Ki[1]))
# self.Ki2_textbox = QLineEdit(self.PID_widget)
# self.Ki2_textbox.move(100, 27)
# self.Ki2_textbox.resize(50, 23)
# self.Ki2_textbox.setValidator(self.onlyDouble)
# self.Ki2_textbox.setText(str(fc.Ki[2]))
# # integral label
# self.Ki_label = QLabel(self.PID_widget)
# self.Ki_label.setText('Integral')
# self.Ki_label.move(150, 27)
# self.Ki_label.resize(85, 23)
# self.Ki_label.setFrameShape(QFrame.Panel)
# self.Ki_label.setFrameShadow(QFrame.Sunken)
# self.Ki_label.setLineWidth(3)
# self.Ki_label.setStyleSheet("background-color:rgb(53,53,53);")
#
# # derivative text
# self.Kd0_textbox = QLineEdit(self.PID_widget)
# self.Kd0_textbox.move(0, 54)
# self.Kd0_textbox.resize(50, 23)
# self.Kd0_textbox.setValidator(self.onlyDouble)
# self.Kd0_textbox.setText(str(fc.Kd[0]))
# self.Kd1_textbox = QLineEdit(self.PID_widget)
# self.Kd1_textbox.move(50, 54)
# self.Kd1_textbox.resize(50, 23)
# self.Kd1_textbox.setValidator(self.onlyDouble)
# self.Kd1_textbox.setText(str(fc.Kd[1]))
# self.Kd2_textbox = QLineEdit(self.PID_widget)
# self.Kd2_textbox.move(100, 54)
# self.Kd2_textbox.resize(50, 23)
# self.Kd2_textbox.setValidator(self.onlyDouble)
# self.Kd2_textbox.setText(str(fc.Kd[2]))
# # derivative label
# self.Kd_label = QLabel(self.PID_widget)
# self.Kd_label.resize(85, 23)
# self.Kd_label.setText('Derivative')
# self.Kd_label.move(150, 54)
# self.Kd_label.setFrameShape(QFrame.Panel)
# self.Kd_label.setFrameShadow(QFrame.Sunken)
# self.Kd_label.setLineWidth(3)
# self.Kd_label.setStyleSheet("background-color:rgb(53,53,53);")
#
# # button to insert new PID values
# self.insert_PID_values = QPushButton("Insert PID Gains", self.PID_widget)
# self.insert_PID_values.setStyleSheet("background-color: #002366;")
# self.insert_PID_values.move(150, 80)
# self.insert_PID_values.resize(85, 25)
# self.insert_PID_values.setFont(QFont("Helvetica", 11.5))
# self.insert_PID_values.setCheckable(True)
# self.insert_PID_values.setEnabled(True)
# self.insert_PID_values.clicked.connect(self.get_PID_value)
#
# # label for Roll, Pitch, Yaw
# self.RPY = QLabel(self.PID_widget)
# self.RPY.move(0,80)
# self.RPY.setText(' Roll Pitch Yaw ')
# self.RPY.setFrameShape(QFrame.Panel)
# self.RPY.setFrameShadow(QFrame.Sunken)
# self.RPY.setLineWidth(3)
# self.RPY.setStyleSheet("background-color:rgb(53,53,53);")
def onUpdateText(self, text):
cursor = self.log.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertText(text)
self.log.setTextCursor(cursor)
self.log.ensureCursorVisible()
def __del__(self):
sys.stdout = sys.__stdout__
# creates a log for the command line output
def create_log(self):
self.log = QTextEdit(self)
self.log.move(l-260, w-465)
self.log.resize(260, w-175)
self.log.moveCursor(QTextCursor.Start)
self.log.ensureCursorVisible()
self.log.setLineWrapMode(QTextEdit.FixedPixelWidth)
self.log.setReadOnly(True)
self.log.setLineWrapColumnOrWidth(250)
try:
sys.stdout = Stream(newText=self.onUpdateText)
except AttributeError as error:
print(error)
# creates data monitor
def create_data_monitor(self):
# make QTimer
self.qTimer = QTimer(self)
# pi connection status
self.pi_connection_status_is_clicked = False
self.pi_connection_label = QPushButton("Pi Connection", self)
self.pi_connection_label.setCheckable(False)
self.pi_connection_label.setEnabled(False)
self.pi_connection_label.setStyleSheet("background: #333332; color: white")
self.pi_connection_label.move(2, 96)
self.pi_connection_label.show()
self.pi_connection_label.resize(80, 20)
self.pi_connection_status = QPushButton("Offline", self)
self.pi_connection_status.move(2,115)
self.pi_connection_status.setDefault(False)
self.pi_connection_status.setEnabled(False)
self.pi_connection_status.setIcon(QIcon('Images/Icons/connection.png'))
self.pi_connection_status.setStyleSheet("background-color: #922B3E;")
# set interval to update
self.qTimer.setInterval(250)
# connect timeout signal to signal handler
self.qTimer.timeout.connect(self.get_sensor_value)
self.qTimer.start()
# creates the plot graph button
def create_motor_output_plot_button(self):
self.plot_button = QPushButton("Motor Output Plot Graph", self.data_tab)
self.plot_button.setStyleSheet("background-color:#002366;")
self.plot_button.setIcon(QIcon("Images/Icons/line_graph.png"))
self.plot_button.clicked.connect(self.create_motor_output_plot)
self.plot_button.move(2,20)
# time stamp for the graph's delta time initialization
self.timestamp = time.time()
# function to start the timer for QTimer
def start_timer(self):
if self.timer.isActive():
# sets the Y Range for the graph
self.pw.setYRange(-2, 2)
print("Graph is already updating at ", self.timer.interval(), " ms between data retrievals")
else:
self.timer.start()
# sets the Y Range for the graph
self.pw.setYRange(-2, 2)
# create a live motor output plot graph
def create_motor_output_plot(self):
self.motor_output_plot_graph_is_open = True
# widget for the motor output graph
self.motor_output_graph_widget = QWidget(self.data_tab)
self.motor_output_graph_widget.resize(l - 260, w - 100)
self.motor_output_graph_widget.show()
# motor 1 output title
self.motor_1_output_title = QPushButton("Motor 1 Output", self.motor_output_graph_widget)
self.motor_1_output_title.move(l - 400, 60)
self.motor_1_output_title.setStyleSheet("background: black; color: gray;")
self.motor_1_output_title.setEnabled(False)
self.motor_1_output_title.setCheckable(False)
self.motor_1_output_title.setFixedSize(90, 13)
self.motor_1_output_title.setFont(QFont("Helvetica", 11.5))
self.motor_1_output_title.show()
self.motor_1_output_title_color = QLabel(self.motor_output_graph_widget)
self.motor_1_output_title_color.setPixmap(QPixmap('Images/Icons/red_square.png'))
self.motor_1_output_title_color.move(l - 413, 60)
self.motor_1_output_title_color.show()
# motor 2 output title
self.motor_2_output_title = QPushButton("Motor 2 Output", self.motor_output_graph_widget)
self.motor_2_output_title_color = QLabel(self.motor_output_graph_widget)
self.motor_2_output_title_color.setPixmap(QPixmap('Images/Icons/blue_square.png'))
self.motor_2_output_title_color.move(l - 413, 90)
self.motor_2_output_title_color.show()
self.motor_2_output_title.move(l - 400, 90)
self.motor_2_output_title.setStyleSheet("background: black; color: gray;")
self.motor_2_output_title.setEnabled(False)
self.motor_2_output_title.setCheckable(False)
self.motor_2_output_title.setFixedSize(90, 13)
self.motor_2_output_title.setFont(QFont("Helvetica", 11.5))
self.motor_2_output_title.show()
# motor 3 output title
self.motor_3_output_title = QPushButton("Motor 3 Output", self.motor_output_graph_widget)
self.motor_3_output_title_color = QLabel(self.motor_output_graph_widget)
self.motor_3_output_title_color.setPixmap(QPixmap('Images/Icons/yellow_square.png'))
self.motor_3_output_title_color.move(l - 413, 120)
self.motor_3_output_title_color.show()
self.motor_3_output_title.move(l - 400, 120)
self.motor_3_output_title.setStyleSheet("background: black; color: gray;")
self.motor_3_output_title.setEnabled(False)
self.motor_3_output_title.setCheckable(False)
self.motor_3_output_title.setFixedSize(90, 13)
self.motor_3_output_title.setFont(QFont("Helvetica", 11.5))
self.motor_3_output_title.show()
# motor 4 output title
self.motor_4_output_title = QPushButton("Motor 4 Output", self.motor_output_graph_widget)
self.motor_4_output_title_color = QLabel(self.motor_output_graph_widget)
self.motor_4_output_title_color.setPixmap(QPixmap('Images/Icons/purple_square.png'))
self.motor_4_output_title_color.move(l - 413, 150)
self.motor_4_output_title_color.show()
self.motor_4_output_title.move(l - 400, 150)
self.motor_4_output_title.setStyleSheet("background: black; color: gray;")
self.motor_4_output_title.setEnabled(False)
self.motor_4_output_title.setCheckable(False)
self.motor_4_output_title.setFixedSize(90, 13)
self.motor_4_output_title.setFont(QFont("Helvetica", 11.5))
self.motor_4_output_title.show()
# motor 1 output
self.motor_1_output = QLabel(str(fc.motor_output[0]), self.motor_output_graph_widget)
self.motor_1_output.move(l - 395, 75)
self.motor_1_output.resize(70, 12)
self.motor_1_output.show()
# motor 2 output
self.motor_2_output = QLabel(str(fc.motor_output[1]), self.motor_output_graph_widget)
self.motor_2_output.move(l - 395, 105)
self.motor_2_output.resize(70, 12)
self.motor_2_output.show()
# motor 3 output
self.motor_3_output = QLabel(str(fc.motor_output[2]), self.motor_output_graph_widget)
self.motor_3_output.move(l - 395, 135)
self.motor_3_output.resize(70, 12)
self.motor_3_output.show()
# motor 4 output
self.motor_4_output = QLabel(str(fc.motor_output[3]), self.motor_output_graph_widget)
self.motor_4_output.move(l - 395, 165)
self.motor_4_output.resize(70, 12)
self.motor_4_output.show()
self.pw = pg.PlotWidget(self.motor_output_graph_widget)
self.pw.showGrid(x=True,y=True)
self.pw.setTitle('Live Update Graph (demonstration with sin function)')
self.pw.move(0,20)
self.pw.resize(l/2,w/2)
self.pw.show()
self.pw.setLabel('left', 'Motor Output')
self.pw.setLabel('bottom', 'Time', units='s')
self.pw.setAntialiasing(True)
# sets the Y Range for the graph
self.pw.setYRange(-2,2)
self.timer = pg.QtCore.QTimer(self)
self.stop_plot_button = QPushButton("Pause", self.motor_output_graph_widget)
self.stop_plot_button.setStyleSheet("background-color:#002366;")
self.stop_plot_button.setIcon(QIcon('Images/Icons/stop.png'))
self.stop_plot_button.clicked.connect(self.timer.stop)
self.stop_plot_button.resize(80,20)
self.stop_plot_button.move(20, 0)
self.stop_plot_button.show()
self.start_plot_button = QPushButton("Start", self.motor_output_graph_widget)
self.start_plot_button.setIcon(QIcon('Images/Icons/play.png'))
self.start_plot_button.resize(80,20)
self.start_plot_button.setStyleSheet("background-color:#002366;")
self.start_plot_button.clicked.connect(self.start_timer)
self.start_plot_button.move(l/2-110,0)
self.start_plot_button.show()
# buffer size for the data
self.buffer = 200
# queue to get the current delta time and values
self.queue = Queue(self.buffer)
# deque containing the values
self.values_1 = deque([], maxlen=self.buffer)
self.values_2 = deque([], maxlen=self.buffer)
self.values_3 = deque([], maxlen = self.buffer)
self.values_4 = deque([], maxlen=self.buffer)
self.values_5 = deque([], maxlen=self.buffer)
# deque containing the delta times
self.times = deque([], maxlen=self.buffer)
def update():
# current delta time
t = time.time() - self.timestamp
# value(s) that we want to track
v1 = fc.motor_output[0]
v2 = fc.motor_output[1]
v3 = fc.motor_output[2]
v4 = fc.motor_output[3]
# demonstration
v5 = np.sin(t)
# put the data into queue
self.queue.put([t,v1,v2,v3,v4,v5])
# get the data from the queue. Will wait until item is available
data = self.queue.get(True, None)
# append data in each deque
self.times.append(data[0])
self.values_1.append(data[1])
self.values_2.append(data[2])
self.values_3.append(data[3])
self.values_4.append(data[4])
self.values_5.append(data[5])
# draw the incoming data
self.pw.clear()
self.pw.plot(x=list(self.times)[-self.buffer:], y=list(self.values_1)[-self.buffer:],pen='r')
self.pw.plot(x=list(self.times)[-self.buffer:], y=list(self.values_2)[-self.buffer:],pen='b')
self.pw.plot(x=list(self.times)[-self.buffer:], y=list(self.values_3)[-self.buffer:],pen='y')
self.pw.plot(x=list(self.times)[-self.buffer:], y=list(self.values_4)[-self.buffer:], pen='m')
self.pw.plot(x=list(self.times)[-self.buffer:], y=list(self.values_5)[-self.buffer:], pen='w')
self.timer.timeout.connect(update)
# length between updates (in ms)
self.timer.start(2)
# gets the sensor's value
def get_sensor_value(self):
# get's the motor output values
if self.motor_output_plot_graph_is_open is True:
self.motor_1_output.setText(str(fc.motor_output[0]))
self.motor_2_output.setText(str(fc.motor_output[1]))
self.motor_3_output.setText(str(fc.motor_output[2]))
self.motor_4_output.setText(str(fc.motor_output[3]))
# determines the status of the pi connection
if fc.pi_online:
self.pi_connection_status.setStyleSheet("background-color: #507D2A")
self.pi_connection_status.setText("Online")
self.pi_connection_status_is_clicked = True
elif not fc.pi_online and self.pi_connection_status_is_clicked:
self.pi_connection_status.setStyleSheet("background-color: #922B3E")
self.pi_connection_status.setText("Offline")
self.pi_connection_status_is_clicked = False
# gets the current PID
self.curr_P.setText(str(fc.Kp))
self.curr_I.setText(str(fc.Ki))
self.curr_D.setText(str(fc.Kd))
# creates labels for the flight motion patterns
def create_flight_motion_labels(self):
# Widget for the flight pattern buttons
self.flight_pattern_widget = QWidget(self.flight_pattern_tab)
self.flight_pattern_widget.resize(200,200)
self.flight_motion_label = QLabel(self.flight_pattern_widget)
self.flight_motion_label.setFrameShape(QFrame.StyledPanel)
self.flight_motion_label.setFrameShadow(QFrame.Raised)
self.flight_motion_label.move(2,20)
self.flight_motion_label.setText("Flight Motion Pattern")
self.square_pattern = QPushButton("Square", self.flight_pattern_widget)
self.square_pattern.setIcon(QIcon('Images/Icons/square.png'))
self.square_pattern.move(2,35)
self.square_pattern.clicked.connect(self.do_square_pattern)
self.square_pattern.setStyleSheet("background-color:#002366;")
# conducts the square pattern
def do_square_pattern(self):
print("Completing Square Flight Motion Pattern...")
print("[Currently Under Development]")
# exits the application
def exit_application(self):
DroneGUI.close(self)
# updates the flight timer
def update_timer(self):
self.time = self.time.addSecs(1)
self.flight_time.setText(self.time.toString("mm:ss"))
# sets the logos for ARC and raspberry pi
def set_logo(self):
self.arc_logo = QLabel(self)
self.arc_logo.setPixmap(QPixmap('Images/CUARClogo.png'))
self.arc_logo.move(l-600,0)
self.pi_logo = QLabel(self)
self.pi_logo.setPixmap(QPixmap('Images/Icons/raspberry_pi_logo.png'))
self.pi_logo.move(87,105)
# shows pop up for the hard wire connections
def show_hard_wire_connections(self):
self.window = QDialog(self.settings_tab)
self.window.setWindowTitle("Settings")
self.window.resize(145,405)
self.window.move(l - 408, 247)
self.window.show()
self.gpio_label = QPushButton("GPIO Reference", self.window)
self.gpio_label.setCheckable(False)
self.gpio_label.setEnabled(False)
self.gpio_label.move(24,1)
self.gpio_label.show()
self.gpio_label.setStyleSheet("background: #333332; color: white")
self.motor_1_label_pic = QLabel(self.window)
self.motor_1_label_pic.setPixmap((QPixmap('Images/Icons/gear.png')))
self.motor_1_label_pic.move(1,28)
self.motor_1_label_pic.show()
self.motor_1_label = QLabel("Motor 1:", self.window)
self.motor_1_label.move(18,30)
self.motor_1_label.show()
self.motor_1_gpio = QLineEdit(self.window)
self.motor_1_gpio.setReadOnly(True)
self.motor_1_gpio.move(90,28)
self.motor_1_gpio.resize(30,12)
self.motor_1_gpio.show()
self.motor_1_gpio.setText(str(fc.motor.MOTOR1))
self.motor_2_label_pic = QLabel(self.window)
self.motor_2_label_pic.setPixmap((QPixmap('Images/Icons/gear.png')))
self.motor_2_label_pic.move(1, 48)
self.motor_2_label_pic.show()
self.motor_2_label = QLabel("Motor 2:", self.window)
self.motor_2_label.move(18, 50)
self.motor_2_label.show()
self.motor_2_gpio = QLineEdit(self.window)
self.motor_2_gpio.setReadOnly(True)
self.motor_2_gpio.move(90, 48)
self.motor_2_gpio.resize(30, 12)
self.motor_2_gpio.show()
self.motor_2_gpio.setText(str(fc.motor.MOTOR2))
self.motor_3_label_pic = QLabel(self.window)
self.motor_3_label_pic.setPixmap((QPixmap('Images/Icons/gear.png')))
self.motor_3_label_pic.move(1, 68)
self.motor_3_label_pic.show()
self.motor_3_label = QLabel("Motor 3:", self.window)
self.motor_3_label.move(18, 70)
self.motor_3_label.show()
self.motor_3_gpio = QLineEdit(self.window)
self.motor_3_gpio.setReadOnly(True)
self.motor_3_gpio.move(90, 68)
self.motor_3_gpio.resize(30, 12)
self.motor_3_gpio.show()
self.motor_3_gpio.setText(str(fc.motor.MOTOR3))
self.motor_4_label_pic = QLabel(self.window)
self.motor_4_label_pic.setPixmap((QPixmap('Images/Icons/gear.png')))
self.motor_4_label_pic.move(1, 88)
self.motor_4_label_pic.show()
self.motor_4_label = QLabel("Motor 4:", self.window)
self.motor_4_label.move(18, 90)
self.motor_4_label.show()
self.motor_4_gpio = QLineEdit(self.window)
self.motor_4_gpio.setReadOnly(True)
self.motor_4_gpio.move(90, 88)
self.motor_4_gpio.resize(30, 12)
self.motor_4_gpio.show()
self.motor_4_gpio.setText(str(fc.motor.MOTOR4))
self.receiver_1_label = QLabel("Receiver 1:", self.window)
self.receiver_1_label.move(18, 110)
self.receiver_1_label.show()
self.receiver_1_label_pic = QLabel(self.window)
self.receiver_1_label_pic.setPixmap((QPixmap("Images/Icons/receiver.png")))
self.receiver_1_label_pic.move(1, 107)
self.receiver_1_label_pic.show()
self.receiver_1_gpio = QLineEdit(self.window)
self.receiver_1_gpio.setReadOnly(True)
self.receiver_1_gpio.move(90,108)
self.receiver_1_gpio.resize(30,12)
self.receiver_1_gpio.show()
self.receiver_1_gpio.setText(str(fc.receiver.RECEIVER_CH1))
self.receiver_2_label = QLabel("Receiver 2:", self.window)
self.receiver_2_label.move(18, 130)
self.receiver_2_label.show()
self.receiver_2_label_pic = QLabel(self.window)
self.receiver_2_label_pic.setPixmap((QPixmap("Images/Icons/receiver.png")))
self.receiver_2_label_pic.move(1, 127)
self.receiver_2_label_pic.show()
self.receiver_2_gpio = QLineEdit(self.window)
self.receiver_2_gpio.setReadOnly(True)
self.receiver_2_gpio.move(90, 128)
self.receiver_2_gpio.resize(30, 12)
self.receiver_2_gpio.show()
self.receiver_2_gpio.setText(str(fc.receiver.RECEIVER_CH2))
self.receiver_3_label = QLabel("Receiver 3:", self.window)
self.receiver_3_label.move(18, 150)
self.receiver_3_label.show()
self.receiver_3_label_pic = QLabel(self.window)
self.receiver_3_label_pic.setPixmap((QPixmap("Images/Icons/receiver.png")))
self.receiver_3_label_pic.move(1, 147)
self.receiver_3_label_pic.show()
self.receiver_3_gpio = QLineEdit(self.window)
self.receiver_3_gpio.setReadOnly(True)
self.receiver_3_gpio.move(90, 148)
self.receiver_3_gpio.resize(30, 12)
self.receiver_3_gpio.show()
self.receiver_3_gpio.setText(str(fc.receiver.RECEIVER_CH3))
self.receiver_4_label = QLabel("Receiver 4:", self.window)
self.receiver_4_label.move(18, 170)
self.receiver_4_label.show()
self.receiver_4_label_pic = QLabel(self.window)
self.receiver_4_label_pic.setPixmap((QPixmap("Images/Icons/receiver.png")))
self.receiver_4_label_pic.move(1, 167)
self.receiver_4_label_pic.show()
self.receiver_4_gpio = QLineEdit(self.window)
self.receiver_4_gpio.setReadOnly(True)
self.receiver_4_gpio.move(90, 168)
self.receiver_4_gpio.resize(30, 12)
self.receiver_4_gpio.show()
self.receiver_4_gpio.setText(str(fc.receiver.RECEIVER_CH4))
self.receiver_5_label = QLabel("Receiver 5:", self.window)
self.receiver_5_label.move(18, 190)
self.receiver_5_label.show()
self.receiver_5_label_pic = QLabel(self.window)
self.receiver_5_label_pic.setPixmap((QPixmap("Images/Icons/receiver.png")))
self.receiver_5_label_pic.move(1, 187)
self.receiver_5_label_pic.show()
self.receiver_5_gpio = QLineEdit(self.window)
self.receiver_5_gpio.setReadOnly(True)
self.receiver_5_gpio.move(90, 188)
self.receiver_5_gpio.resize(30, 12)
self.receiver_5_gpio.show()
self.receiver_5_gpio.setText(str(fc.receiver.RECEIVER_CH5))
self.gpio_label = QPushButton("PWM Frequency (Hz)", self.window)
self.gpio_label.setCheckable(False)
self.gpio_label.setEnabled(False)
self.gpio_label.move(2, 210)
self.gpio_label.show()
self.gpio_label.setStyleSheet("background: #333332; color: white")
self.hz_pic = QLabel(self.window)
self.hz_pic.setPixmap(QPixmap("Images/Icons/freq.png"))
self.hz_pic.move(70,234)
self.hz_pic.show()
self.hz_count = QLineEdit(self.window)
self.hz_count.setReadOnly(True)
self.hz_count.move(84, 235)
self.hz_count.resize(40, 12)
self.hz_count.show()
self.hz_count.setText(str(fc.motor.PWM_frequency))
self.gpio_label = QPushButton("MPU6050 Address", self.window)
self.gpio_label.setCheckable(False)
self.gpio_label.setEnabled(False)
self.gpio_label.move(18, 350)
self.gpio_label.show()
self.gpio_label.setStyleSheet("background: #333332; color: white")
self.imu_pic = QLabel(self.window)
self.imu_pic.setPixmap(QPixmap("Images/Icons/imu.png"))
self.imu_pic.move(81, 374)
self.imu_pic.show()
self.mpu_address = QLineEdit(self.window)
self.mpu_address.setReadOnly(True)
self.mpu_address.move(95, 374)
self.mpu_address.resize(30, 12)
self.mpu_address.show()
self.mpu_address.setText(str(fc.imu.mpu6050_handle))
# sample time
self.sample_time_label = QPushButton("Sample Time (ms)", self.window)
self.sample_time_label.setCheckable(False)
self.sample_time_label.setEnabled(False)
self.sample_time_label.move(20, 300)
self.sample_time_label.show()
self.sample_time = QLineEdit(self.window)
self.sample_time.setReadOnly(True)
self.sample_time.resize(50, 12)
self.sample_time.move(75, 324)
self.sample_time.show()
self.sample_time.setText(str(fc.imu.sample_time))
self.sample_time_label.setStyleSheet("background: #333332; color: white")
self.sample_time_pic = QLabel(self.window)
self.sample_time_pic.setPixmap(QPixmap("Images/Icons/clock.png"))
self.sample_time_pic.move(58, 323)
self.sample_time_pic.show()
# PID input/output limitations
self.io_lim_label = QPushButton("PID Output Limits", self.window)
self.io_lim_label.setCheckable(False)
self.io_lim_label.setEnabled(False)
self.io_lim_label.move(23, 258)
self.io_lim_label.show()
self.io_lim_lower = QLineEdit(self.window)
self.io_lim_lower.setReadOnly(True)
self.io_lim_lower.resize(38,12)
self.io_lim_lower.move(24, 282)
self.io_lim_lower.show()
self.io_lim_lower.setText(str(fc.imu.output_min))
self.io_lim_pic_dwn = QLabel(self.window)
self.io_lim_pic_dwn.setPixmap(QPixmap("Images/Icons/down_arrow.png"))
self.io_lim_pic_dwn.move(9, 280)
self.io_lim_pic_dwn.show()
self.io_lim_hi = QLineEdit(self.window)
self.io_lim_hi.setReadOnly(True)
self.io_lim_hi.resize(38, 12)
self.io_lim_hi.move(87, 282)
self.io_lim_hi.show()
self.io_lim_hi.setText(str(fc.imu.output_max))
self.io_lim_pic_up = QLabel(self.window)
self.io_lim_pic_up.setPixmap(QPixmap("Images/Icons/up_arrow.png"))
self.io_lim_pic_up.move(72, 280)
self.io_lim_pic_up.show()
def show_about_info(self):
self.about_websites = QWidget(self.about_tab)
self.about_websites.move(10,10)
self.about_arc_label = QPushButton("ARC", self.about_websites)
self.about_arc_label.setCheckable(False)
self.about_arc_label.setEnabled(False)
self.about_arc_label.move(0, 10)
self.about_arc_label.show()
self.arc_website = QLabel(self.about_websites)
self.arc_website.move(2,36)
self.arc_website.setText('<a href="http://CUAerialRobotics.github.io/">Aerial Robotics Team</a>')
self.arc_website.setOpenExternalLinks(True)
self.arc_website.show()
self.arc_img = QLabel(self.about_websites)
self.arc_img.setPixmap(QPixmap('Images/CUARC_about_logo.png'))
self.arc_img.move(130,0)
self.arc_img.show()
self.about_git_label = QPushButton("GitHub", self.about_websites)
self.about_git_label.setCheckable(False)
self.about_git_label.setEnabled(False)
self.about_git_label.move(0, 100)
self.about_git_label.show()
self.arc_website_git = QLabel(self.about_websites)
self.arc_website_git.move(2, 126)
self.arc_website_git.setText(
'<a href="https://github.com/CornellAerialRobotics/">GitHub</a>')
self.arc_website_git.setOpenExternalLinks(True)
self.arc_website_git.show()
self.git_img = QLabel(self.about_websites)
self.git_img.setPixmap(QPixmap('Images/GitHub_logo.png'))
self.git_img.move(130, 82)
self.git_img.show()
self.about_comp_label = QPushButton("Competition", self.about_websites)
self.about_comp_label.setCheckable(False)
self.about_comp_label.setEnabled(False)
self.about_comp_label.move(0, 180)
self.about_comp_label.show()
self.comp_website = QLabel(self.about_websites)
self.comp_website.move(2, 204)
self.comp_website.setText(
'<a href="http://www.aerialroboticscompetition.org/">IARC</a>')
self.comp_website.setOpenExternalLinks(True)
self.comp_website.show()
self.comp_website_rules = QLabel(self.about_websites)
self.comp_website_rules.move(2, 224)
self.comp_website_rules.setText(
'<a href="http://www.aerialroboticscompetition.org/rules.php">Mission 8 Rules</a>')
self.comp_website_rules.setOpenExternalLinks(True)
self.comp_website_rules.show()
self.iarc_img = QLabel(self.about_websites)
self.iarc_img.setPixmap(QPixmap('Images/IARC_logo.png'))
self.iarc_img.move(130, 174)
self.iarc_img.show()
self.about_school_label = QPushButton("School", self.about_websites)
self.about_school_label.setCheckable(False)
self.about_school_label.setEnabled(False)
self.about_school_label.move(0, 274)
self.about_school_label.show()
self.school_website = QLabel(self.about_websites)
self.school_website.move(2, 298)
self.school_website.setText(
'<a href="https://www.cornell.edu/">Cornell University</a>')
self.school_website.setOpenExternalLinks(True)
self.school_website.show()
self.cu_img = QLabel(self.about_websites)
self.cu_img.setPixmap(QPixmap('Images/CU_logo.png'))
self.cu_img.move(130, 260)
self.cu_img.show()
class StationView(QMainWindow):
def __init__(self, model: StationModel, station_controller: StationController, frame_drawer: FrameDrawer,
config: dict):
self.__config = config
self.model = model
self.station_controller = station_controller
self.frame_drawer = frame_drawer
self.ui = uic.loadUi(Path(self.__config['resources_path']['ui']))
self.time = QTime(0, 0, 0, 0)
self.update_timer = QTimer()
self.update_timer.start(100)
self.update_timer.timeout.connect(self.update)
self.ui.StartButton.clicked.connect(self.start_robot)
self.ui.StartButton.clicked.connect(self.__display_start_label)
self.ui.StopButton.clicked.connect(self.stop_robot)
super(StationView, self).__init__()
def start_robot(self):
self.station_controller.start_robot()
def stop_robot(self):
subprocess.run(['ssh', '[email protected]', 'pkill', 'python3'])
def update(self):
self.station_controller.update()
self.__draw_environment(self.model.frame)
# update ui with model
self.__update_timer_display()
if self.model.world_camera_is_on:
self.__display_world_camera_image()
if self.model.country_code is not None:
self.__display_flag()
self.__display_country_name()
self.__display_next_cube_color()
if self.model.current_state == State.FINISHED:
self.__display_done_label()
self.update_timer.stop()
def __update_timer_display(self):
t = self.time.addSecs(self.model.passed_time)
display_time = t.toString()
self.ui.lcdNumber.display(display_time)
def __display_start_label(self):
self.ui.StartedLabel.setText("Go")
self.ui.StartedLabel.setStyleSheet('font: 32pt;')
def __display_done_label(self):
self.ui.StartedLabel.setText("Done")
def __display_world_camera_image(self):
resized_image = cv2.resize(self.model.frame, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_CUBIC)
image = QtGui.QImage(resized_image, resized_image.shape[1], resized_image.shape[0],
resized_image.shape[1] * resized_image.shape[2],
QtGui.QImage.Format_RGB888)
pixmap = QtGui.QPixmap()
pixmap.convertFromImage(image.rgbSwapped())
self.ui.videoLabel.setPixmap(pixmap)
def __display_flag(self):
image_path: Path = Path(self.__config['resources_path']['country_flag']
.format(country=self.model.country.name))
flag_pixmap = QtGui.QPixmap(str(image_path))
self.ui.flagPicture.setPixmap(flag_pixmap)
self.ui.flagPicture.setMask(flag_pixmap.mask())
self.ui.flagPicture.show()
def __display_country_name(self):
self.ui.CountryName.setText(self.model.country.name)
def __display_next_cube_color(self):
if self.model.next_cube is None:
self.ui.cube_label.setStyleSheet('background-color:' + Color.TRANSPARENT.name.lower() + ';')
else:
self.ui.cube_label.setStyleSheet('background-color:' + self.model.next_cube.color.name.lower() + ';')
self.ui.cube_label.show()
def __draw_environment(self, frame):
if self.__config['user_interface']['draw_vision_cubes']:
if self.model.vision_environment is not None:
self.frame_drawer.draw_vision_environment(frame, self.model.vision_environment)
if self.model.real_world_environment is not None:
self.frame_drawer.draw_real_world_environment(frame, self.model.real_world_environment)
if self.model.real_path is not None and self.model.real_path:
self.frame_drawer.draw_real_path(frame, self.model.real_path)
if self.model.original_planned_path is not None and self.model.original_planned_path:
self.frame_drawer.draw_original_planned_path(frame, self.model.original_planned_path)
if self.model.revised_planned_path is not None and self.model.revised_planned_path:
self.frame_drawer.draw_revised_planned_path(frame, self.model.revised_planned_path)
if self.model.robot is not None:
self.frame_drawer.draw_robot(frame, self.model.robot)
class MyTrackGui(base_1, form_1):
def __init__(self):
super(base_1, self).__init__()
state_valve1 = False
state_valve2 = False
state_valve3 = False
state_valve4 = False
self.setupUi(self)
self.task_start.clicked.connect(self.clicked_task_start)
self.task_stop.clicked.connect(self.clicked_task_stop)
self.trial_total.setText('90')
# Connect valves
self.valve1.clicked.connect(self.clicked_valve1)
self.valve2.clicked.connect(self.clicked_valve2)
self.valve3.clicked.connect(self.clicked_valve3)
self.valve4.clicked.connect(self.clicked_valve4)
# self.valve2.setChecked(True)
# self.valve4.setChecked(True)
# Connect clock
self.task_timer.setNumDigits(6)
self.currentTime = QTime(0, 0, 0)
self.task_timer.display(self.currentTime.toString("mm:ss"))
self.timer = QTimer(self)
self.timer.timeout.connect(self.clock_tick)
# Connect laser state
self.laser_state.setText(str('OFF'))
# Video
self.timer_video = QTimer(self)
self.timer_video.timeout.connect(self.update_frame)
self.window_video = OwnImageWidget(self.window_video)
self.window_width = self.window_video.frameSize().width()
self.window_height = self.window_video.frameSize().height()
def clock_tick(self):
self.currentTime = self.currentTime.addSecs(1)
self.task_timer.display(self.currentTime.toString('mm:ss'))
def update_frame(self):
if not q.empty():
frame = q.get()
img = frame["img"]
img_height, img_width, img_colors = img.shape
# scale_w = float(self.window_width) / float(img_width)
# scale_h = float(self.window_height) / float(img_height)
scale_w = 240 / float(img_width)
scale_h = 141 / float(img_height)
scale = min([scale_w, scale_h])
if scale == 0:
scale = 1
img = cv2.resize(img,
None,
fx=scale,
fy=scale,
interpolation=cv2.INTER_CUBIC)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
height, width, bpc = img.shape
bpl = bpc * width
image = QtGui.QImage(img.data, width, height, bpl,
QtGui.QImage.Format_RGB888)
self.window_video.setImage(image)
def clicked_task_start(self):
global state, trial_current, idx_sensor, running
# video
running = True
capture_thread.start()
self.timer_video.start(1)
# clock
self.timer_clock.start(1000)
# maze parameters
trial_total = float(self.trial_total.text())
time_high = float(self.laser_hightime.text())
time_low = float(self.laser_lowtime.text())
sensor_on = float(self.laser_on.text())
sensor_off = float(self.laser_off.text())
self.laser_state.setText(str('IDLE'))
# main arduino code
if state:
read_sensor()
if 30 <= trial_current < 60:
while True:
self.laser_state.setText(str('ON'))
if sensor_on <= idx_sensor <= sensor_off:
trigger_laser(time_high, time_low)
break
if trial_current == trial_total:
state = 0
self.task_stop.clicked.connect(self.clicked_task_stop)
def clicked_task_stop(self):
global state
state = 0
self.timer_clock.stop()
self.timer_video.stop()
self.laser_state.setText(str('OFF'))
return state
def clicked_valve1(self):
global state_valve1
state_valve1 = True
return state_valve1
def clicked_valve2(self):
global state_valve2
state_valve2 = True
return state_valve2
def clicked_valve3(self):
global state_valve3
state_valve3 = True
return state_valve3
def clicked_valve4(self):
global state_valve4
state_valve4 = True
return state_valve4
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()
