class QTimeInputDialog(QDialog):
def __init__(self, title='', description='', initial=QtCore.QTime(),
minValue=QtCore.QTime(), maxValue=QtCore.QTime(),
dformat='mm.ss', parent=None):
super().__init__(parent)
self.setWindowTitle(title)
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.setMaximumSize(300, 110)
self.setMinimumSize(300, 110)
self.resize(300, 130)
self.label = QLabel(description, self)
self.label.setGeometry(10, 0, 280, 20)
self.label.setAlignment(QtCore.Qt.AlignCenter)
self.time = QTimeEdit(self)
self.time.setDisplayFormat(dformat)
self.time.setMaximumTime(maxValue)
self.time.setMinimumTime(minValue)
self.time.setTime(initial)
self.time.setGeometry(10, 30, 280, 25)
self.acceptButton = QPushButton(self)
self.acceptButton.setGeometry(QtCore.QRect(180, 80, 100, 25))
self.acceptButton.setText("Ok")
self.rejectButton = QPushButton(self)
self.rejectButton.setGeometry(QtCore.QRect(60, 80, 100, 25))
self.rejectButton.setText("Cancel")
self.rejectButton.clicked.connect(self.reject)
self.acceptButton.clicked.connect(self.accept)
def createEditor(self, parent: QWidget, option: QStyleOptionViewItem, index: QModelIndex):
editor = QTimeEdit(parent)
editor.setDisplayFormat(TIME_FORMAT)
editor.setCurrentSection(QTimeEdit.SecondSection)
editor.setFrame(False)
editor.setAlignment(Qt.AlignCenter)
editor.setButtonSymbols(QAbstractSpinBox.NoButtons)
editor.setCorrectionMode(QAbstractSpinBox.CorrectToNearestValue)
editor.setKeyboardTracking(True)
editor.setProperty("showGroupSeparator", False)
editor.setCalendarPopup(False)
return editor
def createEditor(self, parent, option, index):
editor = QTimeEdit(parent=parent)
editor.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
editor.setMaximumTime(datetime.time(hour=23, minute=30, second=30))
editor.setDisplayFormat("HH:mm:ss")
# setFrame(): tell whether the line edit draws itself with a frame.
# If enabled (the default) the line edit draws itself inside a frame, otherwise the line edit draws itself without any frame.
editor.setFrame(False)
return editor
def createEditor(self, parent, option, index):
editor = QTimeEdit(parent=parent)
editor.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
editor.setMaximumTime(datetime.time(hour=23, minute=30, second=30))
editor.setDisplayFormat("HH:mm:ss")
# setFrame(): tell whether the line edit draws itself with a frame.
# If enabled (the default) the line edit draws itself inside a frame, otherwise the line edit draws itself without any frame.
editor.setFrame(False)
return editor
class StartTimeChangeDialog(QDialog):
def __init__(self):
super().__init__(GlobalAccess().get_main_window())
self.time_format = 'hh:mm:ss'
def exec(self):
self.init_ui()
return super().exec()
def init_ui(self):
self.setWindowTitle(_('Start time change'))
self.setWindowIcon(QIcon(config.ICON))
self.setSizeGripEnabled(False)
self.setModal(True)
self.layout = QFormLayout(self)
self.time_add = QRadioButton(_('Add'))
self.time_add.setChecked(True)
self.time_reduce = QRadioButton(_('Reduce'))
self.time_value = QTimeEdit()
self.time_value.setDisplayFormat(self.time_format)
self.layout.addRow(self.time_add)
self.layout.addRow(self.time_reduce)
self.layout.addRow(self.time_value)
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
self.layout.addRow(button_box)
self.show()
def apply_changes_impl(self):
change_start_time(self.time_add.isChecked(), time_to_otime(self.time_value.time()))
GlobalAccess().get_main_window().refresh()
class CreateNewSMSLink(QDialog):
def __init__(self, *args, **kwargs):
super(CreateNewSMSLink, self).__init__(*args, **kwargs)
self.setAttribute(Qt.WA_DeleteOnClose)
layout = QVBoxLayout()
# 时间布局
date_time_layout = QHBoxLayout()
self.date_edit = QDateEdit(QDate.currentDate())
self.date_edit.setCalendarPopup(True)
self.date_edit.setDisplayFormat('yyyy-MM-dd')
date_time_layout.addWidget(QLabel('日期:'))
date_time_layout.addWidget(self.date_edit)
date_time_layout.addWidget(QLabel('时间:'))
self.time_edit = QTimeEdit(QTime.currentTime())
self.time_edit.setDisplayFormat('HH:mm:ss')
date_time_layout.addWidget(self.time_edit)
date_time_layout.addStretch()
layout.addLayout(date_time_layout)
self.text_edit = QTextEdit()
layout.addWidget(self.text_edit)
layout.addWidget(QPushButton('确定', clicked=self.commit_sms), alignment=Qt.AlignRight)
self.setLayout(layout)
self.setFixedSize(400, 200)
self.setWindowTitle('新建短信通')
# 确定增加
def commit_sms(self):
text = self.text_edit.toPlainText().strip()
if not text:
QMessageBox.information(self,'错误', '请输入内容。')
return
# 提交
try:
r = requests.post(
url=settings.SERVER_ADDR + 'advise/shortmessage/',
headers={'Content-Type': 'application/json;charset=utf8'},
data=json.dumps({
'utoken':settings.app_dawn.value('AUTHORIZATION'),
'custom_time': self.date_edit.text() + ' ' + self.time_edit.text(),
'content': text
})
)
response = json.loads(r.content.decode('utf-8'))
if r.status_code != 201:
raise ValueError(response['message'])
except Exception as e:
QMessageBox.information(self,'错误', str(e))
else:
QMessageBox.information(self,'成功', "新增成功")
self.close()
def addAllIntervals(self):
fromTimeEdit = QTimeEdit()
toTimeEdit = QTimeEdit()
fromTimeEdit.setDisplayFormat("H.m.s.zzz")
toTimeEdit.setDisplayFormat("H.m.s.zzz")
for i in range(self.alternativeIntervals_comboBox.count()):
timeFromInterval, timeToInterval = self.insertIntervalInTimeEdits(
self.alternativeIntervals_comboBox.itemText(i))
fromTimeEdit.setTime(timeFromInterval)
toTimeEdit.setTime(timeToInterval)
self.addInterval(fromTimeEdit=fromTimeEdit,
toTimeEdit=toTimeEdit,
warnings=False)
self.updateComboBoxes()
def initUI(self):
label = QLabel('QTimeEdit')
label.setAlignment(Qt.AlignCenter)
time = QTimeEdit(self)
time.setTime(QTime.currentTime())
time.setTimeRange(QTime(00, 00, 00), QTime.currentTime())
time.setDisplayFormat('a:hh:mm:ss.zzz')
label2 = QLabel('QDateEdit')
label2.setAlignment(Qt.AlignCenter)
self.date_edit = QDateEdit(self)
self.date_edit.setDate(QDate.currentDate())
self.date_edit.setDateRange(QDate(2000, 1, 1), QDate.currentDate())
# self.date_edit.setDisplayFormat('yyyy년 MMMM d일')
self.date_edit.dateChanged.connect(self.dateChange)
self.label3 = QLabel('이곳에 QDateEdit에서 선택된 값이 나타납니다.')
self.label3.setAlignment(Qt.AlignCenter)
label4 = QLabel('QDateTimeEdit')
label4.setAlignment(Qt.AlignCenter)
label5 = QLabel(self)
label5.setAlignment(Qt.AlignCenter)
label5.setText(
f'QDateTime \n 현재 시간은 {QDateTime.currentDateTime().toString("yyyy년 MMMM d일 ap hh시 mm분 ss초.zzz")} 입니다.'
)
dt_edit = QDateTimeEdit(self)
dt_edit.setDateTimeRange(QDateTime(2020, 1, 1, 00, 00, 00),\
QDateTime(2021, 1, 1, 00, 00, 00))
dt_edit.setDisplayFormat('yyyy.MM.dd hh:mm:ss')
vbox = QVBoxLayout()
vbox.addWidget(label)
vbox.addWidget(time)
vbox.addWidget(label2)
vbox.addWidget(self.date_edit)
vbox.addWidget(self.label3)
vbox.addWidget(label4)
vbox.addWidget(label5)
vbox.addWidget(dt_edit)
self.setLayout(vbox)
self.setWindowTitle('QTime, QDateEdit, QDateTimeEdit')
self.setGeometry(300, 300, 400, 300)
self.show()
def group_time_spinbox(self):
group2 = QGroupBox('QTimeEdit')
lbl = QLabel('QTimeEdit')
timeedit = QTimeEdit(self)
timeedit.setTime(QTime.currentTime())
timeedit.setTimeRange(QTime(3, 00, 00), QTime(23, 30, 00))
timeedit.setDisplayFormat('hh:mm:ss')
timeedit.timeChanged.connect(self.time_value_change)
# dateedit.setDateRange(QDate(1900, 1, 1), QDate(2100, 12, 31))
# self.lbl4 = QLabel(QTime.toString(timeedit.dateTime, 'hh:mm:ss'))
self.lbl4 = QLabel(timeedit.time().toString('hh:mm:ss'))
layout_group4 = QHBoxLayout()
layout_group4.addWidget(lbl)
layout_group4.addWidget(timeedit)
layout_group4.addWidget(self.lbl4)
return layout_group4
def initUI(self):
lb = QLabel('QTimeEdit')
te = QTimeEdit(self)
te.setTime(QTime.currentTime())
te.setTimeRange(QTime(3, 00, 00), QTime(23, 30, 00))
te.setDisplayFormat('hh:mm:ss')
vbox = QVBoxLayout()
vbox.addWidget(lb)
vbox.addWidget(te)
vbox.addStretch()
self.setLayout(vbox)
self.show_basic()
def initUI(self):
label = QLabel('QTimeEdit')
time_edit = QTimeEdit(self)
time_edit.setTime(QTime.currentTime())
time_edit.setTimeRange(QTime(3, 00, 00), QTime(23, 30, 00))
time_edit.setDisplayFormat('hh:mm:ss')
vbox = QVBoxLayout()
vbox.addWidget(label)
vbox.addWidget(time_edit)
vbox.addStretch()
self.setLayout(vbox)
self.setWindowTitle('QTimeEdit')
self.setGeometry(300, 300, 300, 200)
self.show()
class PresetSrcSettings(SettingsPage):
ELEMENT = PresetSrc
Name = ELEMENT.Name
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout())
self.layout().setAlignment(Qt.AlignTop)
self.functionGroup = QGroupBox(self)
self.functionGroup.setTitle(translate('PresetSrcSettings', 'Presets'))
self.functionGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.functionGroup)
self.functionCombo = QComboBox(self.functionGroup)
self.functionGroup.layout().addWidget(self.functionCombo)
for function in sorted(PresetSrc.PRESETS.keys()):
self.functionCombo.addItem(function)
self.functionDuration = QTimeEdit(self.functionGroup)
self.functionDuration.setDisplayFormat('HH.mm.ss.zzz')
self.functionGroup.layout().addWidget(self.functionDuration)
def enable_check(self, enabled):
self.functionGroup.setCheckable(enabled)
self.functionGroup.setChecked(False)
def get_settings(self):
if not (self.functionGroup.isCheckable()
and not self.functionGroup.isChecked()):
return {
'preset': self.functionCombo.currentText(),
'duration':
self.functionDuration.time().msecsSinceStartOfDay()
}
return {}
def load_settings(self, settings):
self.functionCombo.setCurrentText(settings.get('preset', ''))
self.functionDuration.setTime(
QTime.fromMSecsSinceStartOfDay(settings.get('duration', 0)))
class LstWidget(QWidget):
def __init__(self, value, lst_base_date, parent=None):
super().__init__(parent)
layout = QHBoxLayout(self)
self.lst_base_date = lst_base_date
# offset to lst base edit
self.days = QSpinBox(self)
self.days.setMinimum(-10) # somewhat arbitrary value
self.days.setValue((value.date() - lst_base_date).days)
layout.addWidget(self.days)
self.time = QTimeEdit(self)
self.time.setDisplayFormat("hh:mm:ss")
self.time.setTime(value.time())
layout.addWidget(self.time)
def dateTime(self):
# will be called by .get of the dialog, expecting a QDateTime return
return QDateTime(datetime.combine(self.lst_base_date,
self.time.time().toPyTime()) +
timedelta(days=self.days.value()))
def joinIntervals(self, interval1, interval2):
interval = interval1.split(' - ')[1] + ' - ' + interval2.split(
' - ')[0]
innerIntervals = [
self.intervals_listBox.item(i).text()
for i in range(self.intervals_listBox.count())
if isIntersectionIntervals(interval,
self.intervals_listBox.item(i).text())
]
if len(innerIntervals) == 0:
timeFromInterval, timeToInterval = self.insertIntervalInTimeEdits(
interval=interval)
self.fromInterval_timeEdit.setTime(timeFromInterval)
self.toInterval_timeEdit.setTime(timeToInterval)
else:
beginInterval, endInterval = interval.split(' - ')
fromTimeEdit = QTimeEdit()
toTimeEdit = QTimeEdit()
fromTimeEdit.setDisplayFormat("H.m.s.zzz")
toTimeEdit.setDisplayFormat("H.m.s.zzz")
for i in range(len(innerIntervals) + 1):
if i == 0:
innerInterval = innerIntervals[i].split(' - ')
current_interval = beginInterval + ' - ' + innerInterval[0]
beginInterval = innerInterval[1]
elif i == len(innerIntervals):
innerInterval = innerIntervals[i - 1].split(' - ')
current_interval = innerInterval[1] + ' - ' + endInterval
else:
innerInterval = innerIntervals[i].split(' - ')
current_interval = beginInterval + ' - ' + innerInterval[0]
beginInterval = innerInterval[1]
timeFromInterval, timeToInterval = self.insertIntervalInTimeEdits(
current_interval)
fromTimeEdit.setTime(timeFromInterval)
toTimeEdit.setTime(timeToInterval)
self.addInterval(fromTimeEdit=fromTimeEdit,
toTimeEdit=toTimeEdit,
warnings=False)
self.updateComboBoxes()
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.datetime_1 = QDateTimeEdit(self) # 1
self.datetime_1.dateChanged.connect(lambda: print('Date Changed!'))
self.datetime_2 = QDateTimeEdit(QDateTime.currentDateTime(), self) # 2
self.datetime_2.setDisplayFormat('yyyy-MM-dd HH:mm:ss')
self.datetime_2.timeChanged.connect(lambda: print('Time Changed!'))
print(self.datetime_2.date())
print(self.datetime_2.time())
print(self.datetime_2.dateTime())
self.datetime_3 = QDateTimeEdit(QDateTime.currentDateTime(), self) # 3
self.datetime_3.dateTimeChanged.connect(
lambda: print('DateTime Changed!'))
self.datetime_3.setCalendarPopup(True)
self.datetime_4 = QDateTimeEdit(QDate.currentDate(), self) # 4
self.datetime_5 = QDateTimeEdit(QTime.currentTime(), self)
self.date = QDateEdit(QDate.currentDate(), self) # 5
self.date.setDisplayFormat('yyyy/MM/dd')
print(self.date.date())
self.time = QTimeEdit(QTime.currentTime(), self) # 6
self.time.setDisplayFormat('HH:mm:ss')
print(self.time.time())
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.datetime_1)
self.v_layout.addWidget(self.datetime_2)
self.v_layout.addWidget(self.datetime_3)
self.v_layout.addWidget(self.datetime_4)
self.v_layout.addWidget(self.datetime_5)
self.v_layout.addWidget(self.date)
self.v_layout.addWidget(self.time)
self.setLayout(self.v_layout)
class WindowClass(QWidget):
def __init__(self, parent=None):
super(WindowClass, self).__init__(parent)
self.btn = QPushButton(self) #self参数则让该按钮显示当前窗体中
self.btn.setText("点击获取日期信息")
self.btn.clicked.connect(self.showdate)
self.dateEdit = QDateEdit(self)
self.timeEdit = QTimeEdit(self)
self.dateTimeEdit = QDateTimeEdit(self)
self.dateEdit.setCalendarPopup(True)
#self.timeEdit.setCalendarPopup(True)#弹出界面是失效的注意；
#self.dateTimeEdit.setCalendarPopup(True)#时间是无法选择的
self.dateEdit.move(10, 200)
self.timeEdit.move(10, 100)
self.dateTimeEdit.move(10, 300)
self.dateEdit.setDisplayFormat("yyyy-MM-dd")
self.timeEdit.setDisplayFormat("HH:mm:ss")
self.dateTimeEdit.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
self.setWindowTitle("QDateEdit和QDateTimeEdit控件使用")
def showdate(self):
print(self.dateEdit.text())
class Window(QWidget):
def __init__(self):
super().__init__()
# Make widgets #################
self.edit1 = QTimeEdit()
self.edit2 = QTimeEdit()
self.edit3 = QTimeEdit()
self.edit1.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
self.edit2.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
self.edit3.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
self.edit1.setMaximumTime(datetime.time(hour=18, minute=30, second=30))
self.edit2.setMaximumTime(datetime.time(hour=18, minute=30, second=30))
self.edit3.setMaximumTime(datetime.time(hour=18, minute=30, second=30))
self.edit1.setTime(datetime.datetime.now().time())
self.edit2.setTime(datetime.datetime.now().time())
self.edit3.setTime(datetime.datetime.now().time())
# Format: see http://doc.qt.io/qt-5/qdatetime.html#toString-2
self.edit1.setDisplayFormat("HH:mm")
self.edit2.setDisplayFormat("HH:mm:ss t")
self.edit3.setDisplayFormat("h m AP")
self.btn = QPushButton("Print")
# Set button slot ##############
self.btn.clicked.connect(self.printText)
# Set the layout ###############
vbox = QVBoxLayout()
vbox.addWidget(self.edit1)
vbox.addWidget(self.edit2)
vbox.addWidget(self.edit3)
vbox.addWidget(self.btn)
self.setLayout(vbox)
def printText(self):
print(self.edit1.text())
print(self.edit2.text())
print(self.edit3.text())
class Window(QWidget):
def __init__(self):
super().__init__()
# Make widgets #################
self.edit1 = QTimeEdit()
self.edit2 = QTimeEdit()
self.edit3 = QTimeEdit()
self.edit1.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
self.edit2.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
self.edit3.setMinimumTime(datetime.time(hour=8, minute=30, second=30))
self.edit1.setMaximumTime(datetime.time(hour=18, minute=30, second=30))
self.edit2.setMaximumTime(datetime.time(hour=18, minute=30, second=30))
self.edit3.setMaximumTime(datetime.time(hour=18, minute=30, second=30))
self.edit1.setTime(datetime.datetime.now().time())
self.edit2.setTime(datetime.datetime.now().time())
self.edit3.setTime(datetime.datetime.now().time())
# Format: see http://doc.qt.io/qt-5/qdatetime.html#toString-2
self.edit1.setDisplayFormat("HH:mm")
self.edit2.setDisplayFormat("HH:mm:ss t")
self.edit3.setDisplayFormat("h m AP")
self.btn = QPushButton("Print")
# Set button slot ##############
self.btn.clicked.connect(self.printText)
# Set the layout ###############
vbox = QVBoxLayout()
vbox.addWidget(self.edit1)
vbox.addWidget(self.edit2)
vbox.addWidget(self.edit3)
vbox.addWidget(self.btn)
self.setLayout(vbox)
def printText(self):
print(self.edit1.text())
print(self.edit2.text())
print(self.edit3.text())
def addRemoveInvoiceTIme(self):
self.toolFrame = QFrame()
self.toolFrame.setWindowTitle("Platinum Sql Date Corrector")
self.toolFrame.setWindowIcon(QIcon("C:\Platinum\Icons\icon_p.ico"))
self.toolFrame.resize(600, 300)
startDate = QDateEdit()
startDate.setDisplayFormat("yyyy-MM-dd")
startTime = QTimeEdit()
startTime.setDisplayFormat("HH:mm:ss")
endDate = QDateEdit()
endDate.setDisplayFormat("yyyy-MM-dd")
endTime = QTimeEdit()
endTime.setDisplayFormat("HH:mm:ss")
timeToAdd = QTimeEdit()
timeToAdd.setDisplayFormat("HH:mm:ss")
runButton = QPushButton("Add Script")
runButton.clicked.connect(
lambda: self.runScript(startDate.text(), startTime.text(
), endDate.text(), endTime.text(), timeToAdd.text()))
subTractScript = QPushButton("Subtract Script")
subTractScript.clicked.connect(
lambda: self.runScript2(startDate.text(), startTime.text(
), endDate.text(), endTime.text(), timeToAdd.text()))
maingrid = QGridLayout()
maingrid.addWidget(QLabel("Start Date"), 0, 0)
maingrid.addWidget(startDate, 0, 1)
maingrid.addWidget(QLabel("Start Time"), 1, 0)
maingrid.addWidget(startTime, 1, 1)
maingrid.addWidget(QLabel("End Date"), 0, 2)
maingrid.addWidget(endDate, 0, 3)
maingrid.addWidget(QLabel("End Time"), 1, 2)
maingrid.addWidget(endTime, 1, 3)
maingrid.addWidget(QLabel("Time"), 2, 0)
maingrid.addWidget(timeToAdd, 2, 1)
maingrid.addWidget(runButton, 3, 0, 1, 4)
maingrid.addWidget(subTractScript, 4, 0, 1, 4)
self.toolFrame.setLayout(maingrid)
self.toolFrame.show()
class CountdownWidget(QWidget):
"""Define custom widget as countdown control panel."""
def __init__(self, ctrl, parent=None):
"""Init completer."""
super().__init__(parent)
self.controller = ctrl
self.createLayout()
self.loadSettings()
self.connect()
def createLayout(self):
"""Create widget to control the countdown browser source."""
layout = QGridLayout()
self.rb_static = QRadioButton(_("Static Countdown to date:"), self)
layout.addWidget(self.rb_static, 0, 0)
self.rb_dynamic = QRadioButton(_("Dynamic Countdown duration:"), self)
self.rb_dynamic.setChecked(True)
self.rb_dynamic.toggled.connect(self.toggleRadio)
layout.addWidget(self.rb_dynamic, 1, 0)
self.te_datetime = QDateTimeEdit()
self.te_datetime.setCalendarPopup(True)
self.te_datetime.setContextMenuPolicy(Qt.CustomContextMenu)
self.te_datetime.customContextMenuRequested.connect(
self.openDateTimeMenu)
layout.addWidget(self.te_datetime, 0, 1)
self.te_duration = QTimeEdit()
self.te_duration.setDisplayFormat("HH 'h' mm 'm' ss 's'")
self.te_duration.setContextMenuPolicy(Qt.CustomContextMenu)
self.te_duration.customContextMenuRequested.connect(
self.openDurationMenu)
layout.addWidget(self.te_duration, 1, 1)
self.event_label = QLabel(' ' + _('Event description:'))
layout.addWidget(self.event_label, 0, 2)
self.le_desc = QLineEdit()
self.le_desc.setAlignment(Qt.AlignCenter)
layout.addWidget(self.le_desc, 0, 3, 1, 2)
self.cb_restart = QCheckBox(
_('Restart countdown when source becomes active'))
layout.addWidget(self.cb_restart, 1, 2, 1, 2)
self.pb_start = QPushButton(" " + _('Start Countdown') + " ")
layout.addWidget(self.pb_start, 1, 4)
layout.setColumnStretch(2, 1)
layout.setColumnStretch(3, 2)
self.setLayout(layout)
def openDateTimeMenu(self, position):
"""Open menu to set date to today."""
menu = QMenu()
act1 = QAction(_("Set Today"))
act1.triggered.connect(self.setToday)
menu.addAction(act1)
menu.exec_(QCursor.pos())
def openDurationMenu(self, position):
"""Open menu to set the duration."""
menu = QMenu()
for duration in [15, 10, 5, 3, 1]:
act = QAction(_("Set {} min").format(duration), menu)
act.triggered.connect(
lambda x, duration=duration: self.setDuration(duration))
menu.addAction(act)
menu.exec_(QCursor.pos())
def setToday(self):
"""Set date to today."""
today = QDateTime.currentDateTime()
today.setTime(self.te_datetime.time())
self.te_datetime.setDateTime(today)
def setFromTimestamp(self, timestamp):
"""Set time and date based on timestamp."""
self.te_datetime.setDateTime(QDateTime.fromTime_t(int(timestamp)))
def setDuration(self, duration):
"""Set the duration."""
self.te_duration.setTime(QTime(0, duration, 0))
def toggleRadio(self):
"""Toggle radio buttion."""
static = self.rb_static.isChecked()
self.te_datetime.setEnabled(static)
self.te_duration.setEnabled(not static)
self.cb_restart.setEnabled(not static)
self.pb_start.setEnabled(not static)
def loadSettings(self):
"""Load data from settings."""
static = scctool.settings.config.parser.getboolean(
"Countdown", "static")
if static:
self.rb_static.setChecked(True)
else:
self.rb_dynamic.setChecked(True)
description = scctool.settings.config.parser.get(
'Countdown', 'description')
self.le_desc.setText(description.strip())
restart = scctool.settings.config.parser.getboolean(
"Countdown", "restart")
self.cb_restart.setChecked(restart)
duration = QTime()
string = scctool.settings.config.parser.get('Countdown',
'duration').strip()
duration = QTime.fromString(string, 'HH:mm:ss')
self.te_duration.setTime(duration)
string = scctool.settings.config.parser.get('Countdown',
'datetime').strip()
datetime = QDateTime.fromString(string, 'yyyy-MM-dd HH:mm')
self.te_datetime.setDateTime(datetime)
def connect(self):
"""Connect all form elements."""
self.le_desc.textChanged.connect(self.changed_description)
self.cb_restart.toggled.connect(self.changed_restart)
self.te_datetime.dateTimeChanged.connect(self.changed_datetime)
self.te_duration.timeChanged.connect(self.changed_duration)
self.rb_static.toggled.connect(self.changed_static)
self.pb_start.pressed.connect(self.start_pressed)
def changed_description(self):
"""Change the description."""
desc = self.le_desc.text().strip()
scctool.settings.config.parser.set('Countdown', 'description', desc)
self.controller.websocketThread.sendData2Path('countdown', "DESC",
desc)
def changed_restart(self):
"""Handle change of restart option."""
restart = self.cb_restart.isChecked()
scctool.settings.config.parser.set('Countdown', 'restart',
str(restart))
self.controller.websocketThread.sendData2Path('countdown', "RESTART",
restart)
def changed_datetime(self, time):
"""Handle change of datetime."""
datetime = time.toString('yyyy-MM-dd HH:mm')
scctool.settings.config.parser.set('Countdown', 'datetime', datetime)
self.sendData()
def changed_duration(self, time):
"""Handle change of duration."""
duration = time.toString('HH:mm:ss')
scctool.settings.config.parser.set('Countdown', 'duration', duration)
self.sendData()
def changed_static(self):
"""Handle change of static/dynamic."""
static = self.rb_static.isChecked()
scctool.settings.config.parser.set('Countdown', 'static', str(static))
self.sendData()
def start_pressed(self):
"""Handle press of the start button."""
self.controller.websocketThread.sendData2Path('countdown', 'START')
def sendData(self):
"""Send the data to the websocket."""
self.controller.websocketThread.sendData2Path(
'countdown', "DATA",
self.controller.websocketThread.getCountdownData())
class FCMUi(QMainWindow):
"""Fldigi Control Maintenance View (GUI)."""
def __init__(self):
"""View initializer"""
super().__init__()
self.setWindowTitle('Fldigi Controller Maintenance')
self.db = SQLiteDB(db_type="fldigi_control.db")
self.setInitialWindowValues()
self.setInitialFormValues()
self.setInitialButtonValues()
self.setInitialProgramsTableValues()
self.setInitialAppValues()
self.setupMethods()
self.loadComboBoxes()
self.loadProgramsTable()
def setInitialAppValues(self):
''' Catch all for various application values. '''
self.setFieldStatus(status=ac.DISABLE)
self.setButtonStatus(ac.APP_STARTUP)
self.dbPending = ac.DBPENDING_NONE
self.primary_key = None
def setInitialButtonValues(self):
''' Setup a button bar and related button group. '''
self.buttonLayout = QHBoxLayout()
self.generalLayout.addLayout(self.buttonLayout)
self.buttonGroup = QButtonGroup()
self.addPushButtons(self.buttonGroup)
def setInitialFormValues(self):
''' Setup a form for data entry. '''
self.frmLayout = QFormLayout()
self.generalLayout.addLayout(self.frmLayout)
self.createFormFields()
def setInitialWindowValues(self):
''' Setup the basic window system. '''
self.generalLayout = QVBoxLayout()
self.centralwidget = QWidget(self)
self.setCentralWidget(self.centralwidget)
self.centralwidget.setLayout(self.generalLayout)
def setInitialProgramsTableValues(self):
''' Setup a table to contain data specific to Fldigi Control values. '''
self.tblPrograms = QTableWidget(self.centralwidget)
self.hboxTable = QHBoxLayout()
self.hboxTable.addWidget(self.tblPrograms)
self.generalLayout.addLayout(self.hboxTable)
self.tblPrograms.setEnabled(True)
self.tblPrograms.setColumnCount(0)
self.tblPrograms.setRowCount(0)
self.tblPrograms.horizontalHeader().setVisible(True)
self.tblPrograms.verticalHeader().setVisible(False)
headerLabels = [
"Id", "Program", "Station", "Freq", "Mode", "BW", "Modem", "Cntr",
"Day", "UTC Time", "Active", "Notes"
]
self.tblPrograms.setColumnCount(len(headerLabels))
self.tblPrograms.setHorizontalHeaderLabels(headerLabels)
#The following column widths follow headerLabels coded above. Id column is set to zero to hide it.
self.tblPrograms.setColumnWidth(0, 0)
self.tblPrograms.setColumnWidth(1, 200)
self.tblPrograms.setColumnWidth(2, 100)
self.tblPrograms.setColumnWidth(3, 100)
self.tblPrograms.setColumnWidth(4, 100)
self.tblPrograms.setColumnWidth(5, 100)
self.tblPrograms.setColumnWidth(6, 100)
self.tblPrograms.setColumnWidth(7, 100)
self.tblPrograms.setColumnWidth(8, 100)
self.tblPrograms.setColumnWidth(9, 100)
self.tblPrograms.setColumnWidth(10, 100)
self.tblPrograms.setColumnWidth(11, 200)
def loadComboBoxes(self):
values = []
select_constants = [
ac.RADIO_FREQUENCIES, ac.CENTER_DATA_FREQUENCIES, ac.MODES,
ac.MODEMS, ac.RADIO_STATIONS, ac.BANDWIDTHS
]
combo_boxes = [
self.frmComboFreq, self.frmComboCenterFreq, self.frmComboMode,
self.frmComboModem, self.frmComboStation, self.frmComboBandwidth
]
for index, select_constant in enumerate(select_constants):
result = self.db.select(retrieveSQL(select_constant))
combo_boxes[index].addItems([x[0] for x in result])
self.frmComboDOW.addItems(
('Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'))
def loadProgramsTable(self):
''' Load the table from the database. '''
self.tblPrograms.setRowCount(0)
self.dbPending = ac.DBPENDING_SELECT
result = self.handleDatabaseRequest()
self.tblPrograms.setRowCount(len(result))
self.tblPrograms.setSortingEnabled(ac.DISABLE)
for record in enumerate(result):
for item in enumerate(record[1]):
self.tblPrograms.setItem(int(record[0]), int(item[0]),
QTableWidgetItem(str(item[1])))
def setupMethods(self):
'''Uses the button group to connect a button via its constant to a method director.'''
self.buttonGroup.buttonClicked[int].connect(self.methodDirector)
self.tblPrograms.clicked.connect(self.tblProgramsClicked)
self.frmComboFreq.currentIndexChanged[str].connect(self.handleComboBox)
def handleComboBox(self):
self.frmComboFreq.currentData()
def methodDirector(self, buttonid):
'''Identifies a button and its related method using a constant and the button id.'''
if buttonid == ac.PUSHBUTTON_QUIT:
self.close()
elif buttonid == ac.PUSHBUTTON_ADD:
self.addButtonAction()
elif buttonid == ac.PUSHBUTTON_CANCEL:
self.cancelButtonAction()
elif buttonid == ac.PUSHBUTTON_SAVE:
self.saveButtonAction()
elif buttonid == ac.PUSHBUTTON_EDIT:
self.editButtonAction()
elif buttonid == ac.PUSHBUTTON_DELETE:
self.deleteButtonAction()
def tblProgramsClicked(self):
self.clearFields()
'''Note the explicit creation of a tuple in the next line. This is to keep Sqlite happy.'''
self.primary_key = (self.tblPrograms.item(
self.tblPrograms.currentRow(), 0).text(), )
self.setButtonStatus(ac.APP_LISTCHANGE)
def deleteButtonAction(self):
''' Set the database pending value, handle the database action, and set button status. '''
self.dbPending = ac.DBPENDING_DELETE
self.handleDatabaseRequest()
self.setButtonStatus(status=ac.APP_DELETE)
def editButtonAction(self):
''' Set the database pending value, handle the database action, and set button status. '''
self.dbPending = ac.DBPENDING_UPDATE
self.setFieldStatus(status=ac.ENABLE)
self.setButtonStatus(ac.APP_EDIT)
tabledata = self.extractTableData()
self.populateFields(tabledata)
self.frmFieldProgram.setFocus()
def populateFields(self, tabledata):
self.primary_key = tabledata[0]
tabledata = tabledata[1:]
fieldlist = [
self.frmFieldProgram, self.frmComboStation, self.frmComboFreq,
self.frmComboMode, self.frmComboBandwidth, self.frmComboModem,
self.frmComboCenterFreq, self.frmComboDOW, self.frmUTCTimeEdit,
self.frmCheckBoxActive, self.frmTextEditNotes
]
for list_index, item in enumerate(fieldlist):
if isinstance(item, QCheckBox):
if tabledata[list_index] == "Yes":
item.setChecked(True)
else:
item.setChecked(False)
elif isinstance(item, QComboBox):
item.setCurrentIndex(item.findText(tabledata[list_index]))
elif isinstance(item, QTimeEdit):
self.frmUTCTimeEdit.setTime(
QTime.fromString(tabledata[list_index], 'hh:mm'))
elif isinstance(item, QLineEdit) or isinstance(item, QTextEdit):
item.setText(tabledata[list_index])
def extractTableData(self):
'''This method primarily gathers data from the Program table widget and places the data into a list which is returned.'''
tabledata = []
for column_number in range(0, self.tblPrograms.columnCount()):
tabledata.append(
self.tblPrograms.item(self.tblPrograms.currentRow(),
column_number).text())
return tabledata
def saveButtonAction(self):
''' Set the database pending value, handle the database action, and set button status. '''
self.setButtonStatus(status=ac.APP_SAVE)
self.handleDatabaseRequest()
self.clearFields()
def handleDatabaseRequest(self):
result = None
field_data = None
if self.dbPending == ac.DBPENDING_SELECT:
result = self.db.select(retrieveSQL(ac.SQL_SELECT_ALL))
elif self.dbPending == ac.DBPENDING_INSERT:
field_data = self.extractFieldData()
self.db.insertData(retrieveSQL(ac.SQL_INSERT), (field_data, ))
self.loadProgramsTable()
elif self.dbPending == ac.DBPENDING_DELETE:
self.db.deleteRow(retrieveSQL(ac.SQL_DELETE), (self.primary_key))
self.loadProgramsTable()
elif self.dbPending == ac.DBPENDING_UPDATE:
field_data = self.extractFieldData()
field_data.append(self.primary_key)
self.db.updateData(retrieveSQL(ac.SQL_UPDATE), field_data)
self.loadProgramsTable()
return result
def extractFieldData(self):
fielddata = []
fieldList = [
self.frmFieldProgram, self.frmComboStation, self.frmComboFreq,
self.frmComboMode, self.frmComboBandwidth, self.frmComboModem,
self.frmComboCenterFreq, self.frmComboDOW, self.frmUTCTimeEdit,
self.frmCheckBoxActive, self.frmTextEditNotes
]
for item in fieldList:
item_text = ''
if isinstance(item, QCheckBox):
item_text = "Yes" if item.isChecked() else "No"
elif isinstance(item, QTextEdit):
item_text = item.toPlainText()
elif isinstance(item, QComboBox):
item_text = item.currentText()
elif isinstance(item, QLineEdit):
item_text = item.displayText()
elif isinstance(item, QTimeEdit):
item_text = item.time().toString('hh:mm')
fielddata.append(item_text)
return fielddata
def cancelButtonAction(self):
'''Perform actions related to the cancel button click.'''
self.dbPending = ac.DBPENDING_NONE
self.clearFields()
self.setFieldStatus(ac.DISABLE)
self.setButtonStatus(ac.APP_CANCEL)
def addButtonAction(self):
'''Perform actions related to the add button click.'''
self.dbPending = ac.DBPENDING_INSERT
self.clearFields()
self.setFieldStatus(status=ac.ENABLE)
self.setButtonStatus(status=ac.APP_ADD)
self.frmFieldProgram.setFocus()
def setButtonStatus(self, status=0):
'''Set buttons on or off depending on the state of the app.'''
# Set default status of all buttons which all but the quit are disabled.
self.btnAdd.setEnabled(False)
self.btnEdit.setEnabled(False)
self.btnCancel.setEnabled(False)
self.btnSave.setEnabled(False)
self.btnDelete.setEnabled(False)
self.btnQuit.setEnabled(True)
# Now, using the status word, set buttons on or off.
if status in (ac.APP_STARTUP, ac.APP_SAVE):
self.btnAdd.setEnabled(True)
elif status == ac.APP_LISTCHANGE:
self.btnAdd.setEnabled(True)
self.btnEdit.setEnabled(True)
self.btnDelete.setEnabled(True)
elif status == ac.APP_ADD:
self.btnAdd.setEnabled(False)
self.btnCancel.setEnabled(True)
self.btnSave.setEnabled(True)
elif status == ac.APP_CANCEL:
self.btnAdd.setEnabled(True)
elif status == ac.APP_DELETE:
self.btnAdd.setEnabled(True)
elif status == ac.APP_EDIT:
self.btnCancel.setEnabled(True)
self.btnSave.setEnabled(True)
def setFieldStatus(self, status):
'''Turns data fields on or off.'''
self.frmFieldProgram.setEnabled(status)
self.frmCheckBoxActive.setEnabled(status)
self.frmTextEditNotes.setEnabled(status)
self.frmComboFreq.setEnabled(status)
self.frmComboMode.setEnabled(status)
self.frmComboCenterFreq.setEnabled(status)
self.frmComboModem.setEnabled(status)
self.frmComboStation.setEnabled(status)
self.frmUTCTimeEdit.setEnabled(status)
self.frmComboBandwidth.setEnabled(status)
self.frmComboDOW.setEnabled(status)
def clearFields(self):
'''Clear all fields of any information.'''
self.frmFieldProgram.setText("")
self.frmCheckBoxActive.setChecked(True)
self.frmTextEditNotes.setText("")
def addPushButtons(self, buttonGroup):
self.btnAdd = QPushButton("&Add", self.centralwidget)
self.buttonLayout.addWidget(self.btnAdd)
buttonGroup.addButton(self.btnAdd, ac.PUSHBUTTON_ADD)
self.btnEdit = QPushButton("&Edit", self.centralwidget)
self.buttonLayout.addWidget(self.btnEdit)
buttonGroup.addButton(self.btnEdit, ac.PUSHBUTTON_EDIT)
self.btnCancel = QPushButton("&Cancel", self.centralwidget)
self.buttonLayout.addWidget(self.btnCancel)
buttonGroup.addButton(self.btnCancel, ac.PUSHBUTTON_CANCEL)
self.btnSave = QPushButton("&Save", self.centralwidget)
self.buttonLayout.addWidget(self.btnSave)
buttonGroup.addButton(self.btnSave, ac.PUSHBUTTON_SAVE)
self.btnDelete = QPushButton("&Delete", self.centralwidget)
self.buttonLayout.addWidget(self.btnDelete)
buttonGroup.addButton(self.btnDelete, ac.PUSHBUTTON_DELETE)
self.btnQuit = QPushButton("&Quit", self.centralwidget)
self.buttonLayout.addWidget(self.btnQuit)
buttonGroup.addButton(self.btnQuit, ac.PUSHBUTTON_QUIT)
def createFormFields(self):
self.frmFieldProgram = QLineEdit(self.centralwidget)
self.frmLayout.addRow("Program:", self.frmFieldProgram)
self.frmComboStation = QComboBox(self.centralwidget)
self.frmLayout.addRow("Station:", self.frmComboStation)
self.frmComboFreq = QComboBox(self.centralwidget)
self.frmLayout.addRow("Station Frequency:", self.frmComboFreq)
self.frmComboMode = QComboBox(self.centralwidget)
self.frmLayout.addRow("Modulation Mode:", self.frmComboMode)
self.frmComboBandwidth = QComboBox(self.centralwidget)
self.frmLayout.addRow("Bandwidth:", self.frmComboBandwidth)
self.frmComboModem = QComboBox(self.centralwidget)
self.frmLayout.addRow("Modem:", self.frmComboModem)
self.frmComboCenterFreq = QComboBox(self.centralwidget)
self.frmLayout.addRow("Center Frequency:", self.frmComboCenterFreq)
#Day of Week = DOW
self.frmComboDOW = QComboBox(self.centralwidget)
self.frmLayout.addRow("UTC Day of Week:", self.frmComboDOW)
self.frmUTCTimeEdit = QTimeEdit(self.centralwidget)
self.frmLayout.addRow("UTC Time:", self.frmUTCTimeEdit)
self.frmUTCTimeEdit.setDisplayFormat('hh:mm')
utctime = QTime.fromString('00:00', 'hh:mm')
self.frmUTCTimeEdit.setTime(utctime)
self.frmCheckBoxActive = QCheckBox(self.centralwidget)
self.frmCheckBoxActive.setChecked(True)
self.frmLayout.addRow("Active:", self.frmCheckBoxActive)
self.frmTextEditNotes = QTextEdit(self.centralwidget)
self.frmLayout.addRow("Notes:", self.frmTextEditNotes)
class MediaCueSettings(SettingsPage):
Name = 'Media-Cue'
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout(self))
# Start time
self.startGroup = QGroupBox(self)
self.startGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.startGroup)
self.startEdit = QTimeEdit(self.startGroup)
self.startEdit.setDisplayFormat('HH.mm.ss.zzz')
self.startGroup.layout().addWidget(self.startEdit)
self.startLabel = QLabel(self.startGroup)
self.startLabel.setAlignment(Qt.AlignCenter)
self.startGroup.layout().addWidget(self.startLabel)
# Stop time
self.stopGroup = QGroupBox(self)
self.stopGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.stopGroup)
self.stopEdit = QTimeEdit(self.stopGroup)
self.stopEdit.setDisplayFormat('HH.mm.ss.zzz')
self.stopGroup.layout().addWidget(self.stopEdit)
self.stopLabel = QLabel(self.stopGroup)
self.stopLabel.setAlignment(Qt.AlignCenter)
self.stopGroup.layout().addWidget(self.stopLabel)
# Loop
self.loopGroup = QGroupBox(self)
self.loopGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.loopGroup)
self.spinLoop = QSpinBox(self.loopGroup)
self.spinLoop.setRange(-1, 1000000)
self.loopGroup.layout().addWidget(self.spinLoop)
self.loopLabel = QLabel(self.loopGroup)
self.loopLabel.setAlignment(Qt.AlignCenter)
self.loopGroup.layout().addWidget(self.loopLabel)
self.retranslateUi()
def retranslateUi(self):
self.startGroup.setTitle('Start time')
self.stopLabel.setText('Stop position of the media')
self.stopGroup.setTitle('Stop time')
self.startLabel.setText('Start position of the media')
self.loopGroup.setTitle('Loop')
self.loopLabel.setText('Repetition after first play (-1 = infinite)')
def get_settings(self):
conf = {'_media_': {}}
checkable = self.startGroup.isCheckable()
if not (checkable and not self.startGroup.isChecked()):
time = self.startEdit.time().msecsSinceStartOfDay()
conf['_media_']['start_time'] = time
if not (checkable and not self.stopGroup.isChecked()):
time = self.stopEdit.time().msecsSinceStartOfDay()
conf['_media_']['stop_time'] = time
if not (checkable and not self.loopGroup.isChecked()):
conf['_media_']['loop'] = self.spinLoop.value()
return conf
def enable_check(self, enable):
self.startGroup.setCheckable(enable)
self.startGroup.setChecked(False)
self.stopGroup.setCheckable(enable)
self.stopGroup.setChecked(False)
self.loopGroup.setCheckable(enable)
self.loopGroup.setChecked(False)
def load_settings(self, settings):
if '_media_' in settings:
if 'loop' in settings['_media_']:
self.spinLoop.setValue(settings['_media_']['loop'])
if 'start_time' in settings['_media_']:
t = self._to_qtime(settings['_media_']['start_time'])
self.startEdit.setTime(t)
if 'stop_time' in settings['_media_']:
t = self._to_qtime(settings['_media_']['stop_time'])
self.stopEdit.setTime(t)
t = self._to_qtime(settings['_media_'].get('duration', 0))
self.startEdit.setMaximumTime(t)
self.stopEdit.setMaximumTime(t)
def _to_qtime(self, m_seconds):
return QTime.fromMSecsSinceStartOfDay(m_seconds)
class TimerWidget(QWidget):
def __init__(self):
super().__init__()
self.initUI()
# Инициализируем плеер и плейлист, на котором поставим цикличное воспроизведение
self.playlist = QMediaPlaylist(self)
self.playlist.setPlaybackMode(QMediaPlaylist.Loop)
self.player = QMediaPlayer()
# Создадим пустую ссылку, чтобы программа не крашилась, если пользователь не выберет мелодию
self.url = QUrl()
# Подскажем для чего кнопка
self.lbl = QLabel('Выберите мелодию для таймера:', self)
self.lbl.move(165, 100)
# Кнопка для выбора файла с мелодией
self.btn_getfile = QPushButton('Выбрать файл', self)
self.btn_getfile.move(200, 125)
self.btn_getfile.resize(100, 50)
self.btn_getfile.clicked.connect(self.getfile)
# Кнопка старта таймера
self.btn_start = QPushButton('Старт', self)
self.btn_start.move(225, 225)
self.btn_start.resize(50, 50)
self.btn_start.clicked.connect(self.start_timer)
# Кнопка остановки таймера до того, как он закончит отсчет
self.btn_stop = QPushButton('Стоп', self)
self.btn_stop.move(250, 225)
self.btn_stop.resize(50, 50)
self.btn_stop.clicked.connect(self.stop_timer)
self.btn_stop.setVisible(False)
# Кнопка паузы таймера
self.btn_pause = QPushButton('Пауза', self)
self.btn_pause.move(200, 225)
self.btn_pause.resize(50, 50)
self.btn_pause.clicked.connect(self.pause_timer)
self.btn_pause.setVisible(False)
# Кнопка для продолжения отсчета таймера
self.btn_continue = QPushButton('Дальше', self)
self.btn_continue.move(200, 225)
self.btn_continue.resize(50, 50)
self.btn_continue.clicked.connect(self.continue_timer)
self.btn_continue.setVisible(False)
# Кнопка для выключения таймера, когда он закончит отсчет
self.btn_off = QPushButton('Выкл', self)
self.btn_off.move(225, 225)
self.btn_off.resize(50, 50)
self.btn_off.clicked.connect(self.timer_off)
self.btn_off.setVisible(False)
# Спрашивваем значение таймера
self.get_timer = QTimeEdit(self)
self.get_timer.move(185, 175)
self.get_timer.resize(130, 50)
self.get_timer.setFont(QFont('Times', 15, QFont.Bold))
self.get_timer.setDisplayFormat('HH:mm:ss')
# Дисплей для вывода таймера
self.dsp = QLCDNumber(self)
self.dsp.resize(200, 50)
self.dsp.move(150, 175)
self.dsp.setVisible(False)
self.dsp.setDigitCount(8)
# Таймер
self.nTimer = QTimer()
self.nTimer.timeout.connect(self.timer)
def initUI(self):
self.setGeometry(100, 100, 500, 500)
self.setWindowTitle('Таймер')
def start_timer(self):
# Добавляем мелодию в плеер
self.content = QMediaContent(self.url)
self.playlist.addMedia(self.content)
self.player.setPlaylist(self.playlist)
# Выводим начальное значение времени на дисплей
self.dsp.display(self.get_timer.time().toString('hh:mm:ss'))
# Переводим время в секунды
timer = self.get_timer.time()
timer_text = timer.toString('hh:mm:ss')
timer_int = list(map(lambda x: int(x), timer_text.split(':')))
self.timer_in_sec = timer_int[0]*3600 + timer_int[1]*60 + timer_int[2]
# Проверяем не установили ли нулевое значение
if self.timer_in_sec == 0:
self.timer_timeout()
else:
# Запускаем таймер
self.nTimer.start(1000)
# Махинации с показом кнопок
self.btn_start.setVisible(False)
self.btn_pause.setVisible(True)
self.btn_stop.setVisible(True)
self.dsp.setVisible(True)
self.get_timer.setVisible(False)
self.lbl.setVisible(False)
self.btn_getfile.setVisible(False)
def timer(self):
# Функция обновления таймера и дисплея со временем
# Делаем обратный отсчет, отнимая каждую секунду единицу из начального значения
self.timer_in_sec -= 1
# Переводим целочисленные значения в строку
timer_text = list(map(lambda x: str(x), [self.timer_in_sec // 3600,
(self.timer_in_sec % 3600) // 60,
(self.timer_in_sec % 3600) % 60]))
# Если один символ, то к нему добавляется ноль
if len(timer_text[0]) == 1:
timer_text[0] = '0' + timer_text[0]
if len(timer_text[1]) == 1:
timer_text[1] = '0' + timer_text[1]
if len(timer_text[2]) == 1:
timer_text[2] = '0' + timer_text[2]
# Объединяем список в формат hh:mm:ss
timer_text = ':'.join(timer_text)
# Выводим текст со временем на дисплей
self.dsp.display(timer_text)
# Если таймер дошел до нуля:
if self.timer_in_sec == 0:
self.timer_timeout()
else:
# Обновляем таймер
self.nTimer.start(1000)
def stop_timer(self):
# Останавливаем таймер
self.nTimer.stop()
# Махинации с кнопками
self.btn_start.setVisible(True)
self.btn_stop.setVisible(False)
self.btn_pause.setVisible(False)
self.dsp.setVisible(False)
self.btn_continue.setVisible(False)
self.get_timer.setVisible(True)
self.btn_getfile.setVisible(True)
self.lbl.setVisible(True)
def continue_timer(self):
# Продолжаем таймер с того места, где остановились
self.nTimer.start(self.inter)
# Махинации с показом кнопок
self.btn_continue.setVisible(False)
self.btn_pause.setVisible(True)
def pause_timer(self):
# Ловим оставшееся время таймера
self.inter = self.nTimer.remainingTime()
# Останавливаем таймер и делаем махинации с показом кнопок
self.nTimer.stop()
self.btn_pause.setVisible(False)
self.btn_continue.setVisible(True)
def timer_off(self):
# Махинации с кнопками
self.btn_start.setVisible(True)
self.dsp.setVisible(False)
self.get_timer.setVisible(True)
self.btn_off.setVisible(False)
self.btn_getfile.setVisible(True)
self.lbl.setVisible(True)
# Останавливаем мелодию
self.player.stop()
def timer_timeout(self):
# Останавливаем таймер
self.nTimer.stop()
# Махинации с кнопками
self.get_timer.setVisible(False)
self.btn_stop.setVisible(False)
self.btn_pause.setVisible(False)
self.btn_continue.setVisible(False)
self.btn_off.setVisible(True)
self.dsp.setVisible(True)
self.lbl.setVisible(False)
self.btn_getfile.setVisible(False)
# Запускаем функцию воспроизведения мелодии
self.playmus()
def playmus(self):
# Воспроизводим мелодию
self.player.play()
def getfile(self):
# Достаем файл с мелодией и сохраняем её путь
fname = QFileDialog.getOpenFileName(self, 'Open File', '/home', 'Audio Files (*mp3 *wav)')
self.url = QUrl.fromLocalFile(fname[0])
class BlinkWindow(QMainWindow):
def __init__(self, parent, *arg, **kwargs):
'''
Initialize the Window.
'''
super().__init__(parent)
self.parent = parent
self.setWindowTitle('TopWatch - Setup blinking')
self.setWindowFlags(Qt.Dialog)
sizeObject = QDesktopWidget().screenGeometry(-1)
self.setGeometry(sizeObject.width() // 2,
sizeObject.height() // 2,
self.geometry().width(),
self.geometry().height())
# Time edit label
self.teditTxt = QLabel()
self.teditTxt.setText('Period (hh:mm:ss)')
# Time edit widget
self.tedit = QTimeEdit(self)
self.tedit.setDisplayFormat('hh:mm:ss')
self.tedit.setTime(self.parent.blinkPeriod)
# Duration edit label
self.lenTxt = QLabel()
self.lenTxt.setText('Duration (ms)')
# Duration edit widget
self.lenedit = QDoubleSpinBox(self)
self.lenedit.setDecimals(0)
self.lenedit.setMaximum(10000)
self.lenedit.setMinimum(50)
self.lenedit.setValue(self.parent.blinkFreq)
# Blink number edit label
self.blnbTxt = QLabel()
self.blnbTxt.setText('Blink number')
# Blink number edit widget
self.blnbedit = QDoubleSpinBox(self)
self.blnbedit.setValue(self.parent.blinkNb)
self.blnbedit.setDecimals(0)
self.blnbedit.setMinimum(1)
# Ok button setup
self.okButton = QPushButton(self)
self.okButton.setText('Ok')
self.okButton.clicked.connect(self.ok)
self.okButton.setToolTip("Activate blinking")
# Cancel button setup
self.cancelButton = QPushButton(self)
self.cancelButton.setText('Cancel')
self.cancelButton.clicked.connect(self.cancel)
self.cancelButton.setToolTip("Cancel blinking setup")
# Layout
self.layout = QGridLayout()
self.layout.addWidget(self.teditTxt, 0, 0)
self.layout.addWidget(self.tedit, 1, 0)
self.layout.addWidget(self.lenTxt, 2, 0)
self.layout.addWidget(self.lenedit, 3, 0)
self.layout.addWidget(self.blnbTxt, 2, 1)
self.layout.addWidget(self.blnbedit, 3, 1)
self.layout.addWidget(self.okButton, 4, 0)
self.layout.addWidget(self.cancelButton, 4, 1)
self.mainWidget = QWidget()
self.mainWidget.setLayout(self.layout)
self.setCentralWidget(self.mainWidget)
###############################
# Methods #
###############################
def cancel(self, *args, **kwargs):
'''When cancel is pressed blinking parameters are updated it the user wants to save later on.'''
self.parent.blinkNb = self.blnbedit.value()
self.parent.blinkPeriod = self.tedit.time()
self.parent.blinkFreq = self.lenedit.value()
self.close()
return
def keyPressEvent(self, e, *args, **kwargs):
'''Actions taken when a key is pressed.'''
if e.key() == Qt.Key_Escape:
self.cancel(*args, **kwargs)
elif e.key() == Qt.Key_Return:
self.ok(*args, **kwargs)
return
def ok(self, *args, **kwargs):
'''Start blinking when ok is pressed.'''
self.parent.start_blink(self.lenedit.value(), self.tedit.time(),
self.blnbedit.value())
self.close()
return
class VCTimeCounter(QWidget):
timeChanged = pyqtSignal(QTime)
def __init__(self, parent=None):
super(VCTimeCounter, self).__init__(parent)
self.parent = parent
self.timeedit = QTimeEdit(QTime(0, 0))
self.timeedit.setObjectName('timeCounter')
self.timeedit.setStyle(QStyleFactory.create('Fusion'))
self.timeedit.setFrame(False)
self.timeedit.setDisplayFormat('hh:mm:ss.zzz')
self.timeedit.timeChanged.connect(self.timeChangeHandler)
separator = QLabel('/')
separator.setObjectName('timeSeparator')
self.duration = QLabel('00:00:00.000')
self.duration.setObjectName('timeDuration')
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(5)
layout.addWidget(self.timeedit)
layout.addWidget(separator)
layout.addWidget(self.duration)
self.setLayout(layout)
def setRange(self, minval: str, maxval: str) -> None:
self.timeedit.setTimeRange(QTime.fromString(minval, 'hh:mm:ss.zzz'),
QTime.fromString(maxval, 'hh:mm:ss.zzz'))
def setMinimum(self, val: str = None) -> None:
if val is None:
self.timeedit.setMinimumTime(QTime(0, 0))
else:
self.timeedit.setMinimumTime(QTime.fromString(val, 'hh:mm:ss.zzz'))
def setMaximum(self, val: str) -> None:
self.timeedit.setMaximumTime(QTime.fromString(val, 'hh:mm:ss.zzz'))
def setTime(self, time: str) -> None:
self.timeedit.setTime(QTime.fromString(time, 'hh:mm:ss.zzz'))
def setDuration(self, time: str) -> None:
self.duration.setText(time)
self.setMaximum(time)
def clearFocus(self) -> None:
self.timeedit.clearFocus()
def hasFocus(self) -> bool:
if self.timeedit.hasFocus():
return True
return super(VCTimeCounter, self).hasFocus()
def reset(self) -> None:
self.timeedit.setTime(QTime(0, 0))
self.setDuration('00:00:00.000')
def setReadOnly(self, readonly: bool) -> None:
self.timeedit.setReadOnly(readonly)
if readonly:
self.timeedit.setButtonSymbols(QAbstractSpinBox.NoButtons)
else:
self.timeedit.setButtonSymbols(QAbstractSpinBox.UpDownArrows)
@pyqtSlot(QTime)
def timeChangeHandler(self, newtime: QTime) -> None:
if self.timeedit.hasFocus():
self.timeChanged.emit(newtime)
class SeekSettings(SettingsPage):
Name = 'Seek Settings'
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cue_id = -1
self.setLayout(QVBoxLayout(self))
self.cueDialog = CueListDialog(
cues=Application().cue_model.filter(MediaCue), parent=self)
self.cueGroup = QGroupBox(self)
self.cueGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.cueGroup)
self.cueButton = QPushButton(self.cueGroup)
self.cueButton.clicked.connect(self.select_cue)
self.cueGroup.layout().addWidget(self.cueButton)
self.cueLabel = QLabel(self.cueGroup)
self.cueLabel.setAlignment(QtCore.Qt.AlignCenter)
self.cueGroup.layout().addWidget(self.cueLabel)
self.seekGroup = QGroupBox(self)
self.seekGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.seekGroup)
self.seekEdit = QTimeEdit(self.seekGroup)
self.seekEdit.setDisplayFormat('HH.mm.ss.zzz')
self.seekGroup.layout().addWidget(self.seekEdit)
self.seekLabel = QLabel(self.seekGroup)
self.seekLabel.setAlignment(QtCore.Qt.AlignCenter)
self.seekGroup.layout().addWidget(self.seekLabel)
self.layout().addSpacing(200)
self.retranslateUi()
def retranslateUi(self):
self.cueGroup.setTitle('Cue')
self.cueButton.setText('Click to select')
self.cueLabel.setText('Not selected')
self.seekGroup.setTitle('Seek')
self.seekLabel.setText('Time to reach')
def select_cue(self):
if self.cueDialog.exec_() == self.cueDialog.Accepted:
cue = self.cueDialog.selected_cues()[0]
self.cue_id = cue.id
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
def enable_check(self, enabled):
self.cueGroup.setCheckable(enabled)
self.cueGroup.setChecked(False)
self.seekGroup.setCheckable(enabled)
self.seekGroup.setChecked(False)
def get_settings(self):
return {'target_id': self.cue_id,
'time': self.seekEdit.time().msecsSinceStartOfDay()}
def load_settings(self, settings):
if settings is not None:
cue = Application().cue_model.get(settings['target_id'])
if cue is not None:
self.cue_id = settings['target_id']
self.seekEdit.setTime(
QTime.fromMSecsSinceStartOfDay(settings['time']))
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
class SongList(QWidget):
def __init__(self, parent=None):
super(SongList, self).__init__(parent)
os.chdir(os.path.dirname(os.path.abspath(__file__)))
resourcesPath = os.getcwd()
resourcesPath = os.path.join(resourcesPath, "resources")
self.PLAY_ICON = QIcon(QPixmap(os.path.join(resourcesPath, "play.png")))
self.PAUSE_ICON = QIcon(QPixmap(os.path.join(resourcesPath, "pause.png")))
self.STOP_ICON = QIcon(QPixmap(os.path.join(resourcesPath, "stop.png")))
self.DELETE_ICON = QIcon(QPixmap(os.path.join(resourcesPath, "delete.png")))
self.setupMediaPlayer()
self.setupUi()
def setupMediaPlayer(self):
self.mediaPlayer = QMediaPlayer()
self.mediaPlayer.setNotifyInterval(1)
self.mediaPlayer.stateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
def setupUi(self):
self.setWindowTitle("List of songs")
mainLayout = QHBoxLayout(self)
verticalListLayout = QVBoxLayout()
self.songsListWidget = QListWidget()
self.songsListWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.songsListWidget.customContextMenuRequested.connect(self.listWidgetRightClick)
verticalListLayout.addWidget(self.songsListWidget)
miniHorizontalLayout = QHBoxLayout()
locatorLine = QLineEdit()
locatorLine.setPlaceholderText("Locator")
locatorBox = QComboBox()
items = ["Title", "Status", "Description", "Style", "All"]
locatorBox.addItems(items)
locatorBox.setCurrentIndex(len(items)-1)
miniHorizontalLayout.addWidget(locatorLine)
miniHorizontalLayout.addWidget(locatorBox)
locatorLine.textChanged.connect(lambda:self.populateList(locatorLine.text(), locatorBox.currentText()))
verticalListLayout.addLayout(miniHorizontalLayout)
self.mainForm = QGroupBox()
self.mainForm.setTitle("Details")
mainLayout.addLayout(verticalListLayout)
mainLayout.addWidget(self.mainForm)
self.populateList()
self.mainFormSetupUi()
#self.show()
self.songsListWidget.currentRowChanged.connect(self.changePage)
def mainFormSetupUi(self):
"""title, status style, duration, descriptin, location, project,
variation_another_song, timestamp"""
mainLayout = QVBoxLayout(self.mainForm)
#Horizontal Layout 1
horizontalLayout1 = QHBoxLayout()
titleLabel = QLabel("Song name:")
self.titleEdit = QLineEdit()
self.titleEdit.editingFinished.connect(self.checkSong)
self.titleEdit.textChanged.connect(self.validateSong)
horizontalLayout1.addWidget(titleLabel)
horizontalLayout1.addWidget(self.titleEdit)
#Horizontal Layout 2
horizontalLayout2 = QHBoxLayout()
statusLabel = QLabel("Status:")
self.statusBox = QComboBox()
dateLabel = QLabel("Date:")
self.dateEdit = QDateTimeEdit()
self.dateEdit.setCalendarPopup(True)
horizontalLayout2.addWidget(statusLabel)
horizontalLayout2.addWidget(self.statusBox)
horizontalLayout2.addStretch(1)
horizontalLayout2.addWidget(dateLabel)
horizontalLayout2.addWidget(self.dateEdit)
#Style Groupbox, widgets added automatically
self.styleGroupBox = QGroupBox()
self.styleGroupBox.setTitle("Style:")
self.styleLayout = QGridLayout(self.styleGroupBox)
horizontalLayout3 = QHBoxLayout()
durationLabel = QLabel("Duration:")
self.durationLine = QTimeEdit()
self.durationLine.setDisplayFormat("mm:ss")
projectLabel = QLabel("Project")
self.projectComboBox = QComboBox()
self.projectComboBox.setEditable(True)
horizontalLayout3.addWidget(durationLabel)
horizontalLayout3.addWidget(self.durationLine)
horizontalLayout3.addWidget(projectLabel)
horizontalLayout3.addWidget(self.projectComboBox)
horizontalLayout4 = QHBoxLayout()
descriptionLabel = QLabel("Description:")
variationLabel = QLabel("Variation from another song: ")
self.variationLine = QLineEdit()
horizontalLayout4.addWidget(descriptionLabel)
horizontalLayout4.addStretch(1)
horizontalLayout4.addWidget(variationLabel)
horizontalLayout4.addWidget(self.variationLine)
self.descriptionTextEdit = QTextEdit()
horizontalLayout5 = QHBoxLayout()
locationLabel = QLabel("Location:")
self.locationLine = QLineEdit()
self.locationButton = QPushButton("...")
self.locationButton.clicked.connect(self.locateFile)
horizontalLayout5.addWidget(locationLabel)
horizontalLayout5.addWidget(self.locationLine)
horizontalLayout5.addWidget(self.locationButton)
horizontalLayout6 = QHBoxLayout()
self.slider = QSlider(Qt.Horizontal)
self.slider.sliderReleased.connect(self.playSlider)
self.slider.setStyleSheet("QSlider::handle:horizontal { border: 1px solid #777; background:#b55858;}")
horizontalLayout6.addWidget(self.slider)
horizontalLayout7 = QHBoxLayout()
self.playButton = QPushButton()
self.stopButton = QPushButton()
self.playButton.setIcon(self.PLAY_ICON)
self.stopButton.setIcon(self.STOP_ICON)
self.playButton.clicked.connect(self.playSong)
self.stopButton.clicked.connect(self.stopSong)
horizontalLayout7.addStretch(1)
horizontalLayout7.addWidget(self.playButton)
horizontalLayout7.addWidget(self.stopButton)
horizontalLayout7.addStretch(1)
horizontalLayout8 = QHBoxLayout()
self.saveButton = QPushButton()
self.saveButton.setText("Save")
self.saveButton.clicked.connect(self.saveSong)
horizontalLayout8.addStretch(1)
horizontalLayout8.addWidget(self.saveButton)
mainLayout.addLayout(horizontalLayout1)
mainLayout.addLayout(horizontalLayout2)
mainLayout.addWidget(self.styleGroupBox)
mainLayout.addLayout(horizontalLayout3)
mainLayout.addLayout(horizontalLayout4)
mainLayout.addWidget(self.descriptionTextEdit)
mainLayout.addLayout(horizontalLayout5)
mainLayout.addLayout(horizontalLayout6)
mainLayout.addLayout(horizontalLayout7)
mainLayout.addLayout(horizontalLayout8)
def clearForm(self):
self.titleEdit.clear()
self.statusBox.clear()
for widget in self.styleGroupBox.children():
if not isinstance(widget, QGridLayout):
widget.deleteLater()
self.durationLine.clear()
self.projectComboBox.clear()
self.variationLine.clear()
self.descriptionTextEdit.clear()
self.locationLine.clear()
def changePage(self, index):
title = self.songsListWidget.item(index).data(Qt.UserRole)
self.clearForm()
self.populateForm(title)
self.slider.setValue(0)
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)
def populateList(self, locatorItem=None, locatorColumn=None):
print(locatorItem, locatorColumn)
self.songsListWidget.blockSignals(True)
self.songsListWidget.clear()
if locatorItem == None or locatorItem == "":
listArray = queries("""SELECT title, status, timestamp from songs """)
print(listArray)
else:
if locatorColumn != "All": #No strings concatenation, no security holes
if locatorColumn == "Title":
sql = """SELECT title, status, timestamp from songs where title LIKE ?"""
elif locatorColumn == "Status":
sql = """SELECT title, status, timestamp from songs where status LIKE ?"""
elif locatorColumn == "Description":
sql = """SELECT title, status, timestamp from songs where description LIKE ?"""
elif locatorColumn == "Style":
sql = """SELECT title, status, timestamp from songs where style LIKE ?"""
locatorItem = "%" + locatorItem + "%"
listArray = queries(sql, (locatorItem,))
else:
locatorItem = "%" + locatorItem + "%"
variables = [locatorItem, locatorItem, locatorItem, locatorItem, locatorItem]
listArray = queries("""SELECT title, status, timestamp from songs
where title LIKE ? OR type LIKE ? OR original_song LIKE ? OR link LIKE ?
OR description LIKE ?""", variables)
for item in listArray:
title = item[0]
status = item[1]
timestamp = item[2]
try:
timestamp = datetime.strptime(timestamp, "%d/%m/%Y %H:%M")
timestamp = timestamp.strftime("%d/%m/%Y")
except:
timestamp = ""
text = "%s %s %s" % (title, status, timestamp)
qItem = QListWidgetItem(text)
qItem.setData(Qt.UserRole, title)
self.songsListWidget.addItem(qItem)
#new idea
qItem = QListWidgetItem("New song...")
qItem.setData(Qt.UserRole, "New song...") #otherwise that would be an error
self.songsListWidget.addItem(qItem)
self.songsListWidget.blockSignals(False)
def listWidgetRightClick(self, position):
widgetItem = self.songsListWidget.itemAt(position)
if widgetItem != None: #quick lazy text fix
if widgetItem.text() != "New song...":
print(widgetItem.text())
menu = QMenu()
deleteAction = QAction(self.DELETE_ICON, "Delete song")
menu.addAction(deleteAction)
action = menu.exec(self.mapToGlobal(position))
if action == deleteAction:
msg = QMessageBox.question(None, "Delete?", "Are you sure you want to delete this entry?")
if msg == QMessageBox.Yes:
title = widgetItem.data(Qt.UserRole)
queries("DELETE from songs where title = ?", (title,))
self.populateList()
self.songsListWidget.setCurrentRow(0)
def songVariations(self):
sql = "SELECT title from songs"
songArray = []
for song in queries(sql)[0]:
songArray.append(song)
return songArray
def checkBoxPositionAsignment(self):
self.y += 1
if self.y == 4:
self.y = 0
self.x += 1
def addStyle(self, text=""):
"text = "" if comes from outside"
self.styleEdit = QLineEdit()
self.styleEdit.setPlaceholderText("Style")
self.styleEdit.textChanged.connect(self.validateStyle)
self.styleEdit.returnPressed.connect(lambda: self.addStyle(self.styleEdit.text()))
if text != "":
self.styleLayout.takeAt(self.styleLayout.count()-1).widget().deleteLater()
styleCheckBox = QCheckBox()
styleCheckBox.setText(text)
print(text)
self.styleLayout.addWidget(styleCheckBox, self.x, self.y)
self.checkBoxPositionAsignment()
print(self.durationLine.text())
self.styleLayout.addWidget(self.styleEdit)
def checkSong(self):
text = self.titleEdit.text()
sql = "SELECT title from songs where title = ?"
if len(queries(sql, (text,))) != 0:
self.titleEdit.setText("")
def validateSong(self):
pass
#VALIDATE REG EXP
def validateStyle(self, text):
if "," in text:
self.styleEdit.undo()
def playSong(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def mediaStateChanged(self):
if self.mediaPlayer.state() == QMediaPlayer.PlayingState:
self.playButton.setIcon(self.PAUSE_ICON)
else:
self.playButton.setIcon(self.PLAY_ICON)
def positionChanged(self, position):
if position != self.mediaPlayer.duration():
self.slider.setValue(position)
def durationChanged(self, duration):
if duration != self.mediaPlayer.position():
print("duration chagned")
self.slider.setRange(0, duration)
def playSlider(self):
self.mediaPlayer.setPosition(self.slider.value())
def stopSong(self):
self.mediaPlayer.stop()
def locateFile(self):
self.fileSystem = QFileDialog(filter="Sound files (*.wav *.mp3 *.flac)")
self.fileSystem.show()
self.fileSystem.fileSelected.connect(self.fileLoaded)
def fileLoaded(self, path):
self.locationLine.setText(path)
try:
self.playlist = QMediaPlaylist()
self.playlist.addMedia(QMediaContent(QUrl.fromLocalFile(path)))
self.mediaPlayer.setPlaylist(self.playlist)
except:
print("fail")
self.slider.setVisible(True)
self.playButton.setVisible(True)
self.stopButton.setVisible(True)
def saveSong(self):
title = self.titleEdit.text()
status = self.statusBox.currentText()
date = self.dateEdit.text()
style = ""
print(status, style)
x = 0
for checkBox in self.styleGroupBox.children():
if isinstance(checkBox, QCheckBox):
if checkBox.isChecked():
style += (checkBox.text()) + ","
x+=1
if x != 0: style = style.rstrip(",")
else: style = None
duration = self.durationLine.time()
duration = QTime(0, 0).secsTo(duration)
project = self.projectComboBox.currentText()
variation = self.variationLine.text()
description = self.descriptionTextEdit.toPlainText()
location = self.locationLine.text()
variables = [title, status, description, location, project,\
variation, date, style, duration]
print("---------", variables)
sql = """INSERT OR REPLACE into songs
(title, status, description, location, project,
variation_another_song, timestamp, style, duration)
values
(?, ?, ?, ?, ?,
?, ?, ?, ?)"""
queries(sql, variables)
self.populateList()
class Downtime(QDialog):
"""
Class who create Downtime QDialog for hosts/services
"""
def __init__(self, parent=None):
super(Downtime, self).__init__(parent)
self.setWindowTitle('Request a Downtime')
self.setWindowFlags(Qt.FramelessWindowHint)
self.setStyleSheet(get_css())
self.setWindowIcon(QIcon(get_image_path('icon')))
self.setMinimumSize(360, 460)
# Fields
self.fixed = True
self.duration = QTimeEdit()
self.start_time = QDateTimeEdit()
self.end_time = QDateTimeEdit()
self.comment_edit = QTextEdit()
def initialize(self, item_type, item_name, comment):
"""
Initialize Downtime QDialog
:param item_type: type of item to acknowledge : host | service
:type item_type: str
:param item_name: name of the item to acknowledge
:type item_name: str
:param comment: the default comment of action
:type comment: str
"""
# Main layout
main_layout = QVBoxLayout(self)
main_layout.setContentsMargins(0, 0, 0, 0)
main_layout.addWidget(get_logo_widget(self))
downtime_widget = QWidget()
downtime_widget.setObjectName('login')
downtime_layout = QGridLayout(downtime_widget)
ack_title = QLabel('<h2>Request a downtime</h2>')
downtime_layout.addWidget(ack_title, 0, 0, 1, 3)
host_label = QLabel('<h2>%s: %s</h2>' %
(item_type.capitalize(), item_name))
downtime_layout.addWidget(host_label, 1, 0, 1, 1)
options_label = QLabel('Downtime options:')
options_label.setObjectName('actions')
downtime_layout.addWidget(options_label, 2, 0, 1, 1)
fixed_checkbox = QCheckBox()
fixed_checkbox.setObjectName('actions')
fixed_checkbox.setChecked(self.fixed)
fixed_checkbox.setFixedSize(18, 18)
downtime_layout.addWidget(fixed_checkbox, 2, 1, 1, 1)
fixed_label = QLabel('Fixed')
fixed_label.setObjectName('actions')
downtime_layout.addWidget(fixed_label, 2, 2, 1, 1)
fixed_info = QLabel(
'<i>If checked, downtime will start and end at the times specified'
' by the “start time” and “end time” fields.</i>')
fixed_info.setWordWrap(True)
downtime_layout.addWidget(fixed_info, 3, 0, 1, 3)
duration_label = QLabel('Duration')
duration_label.setObjectName('actions')
downtime_layout.addWidget(duration_label, 4, 0, 1, 1)
duration_clock = QLabel()
duration_clock.setPixmap(QPixmap(get_image_path('clock')))
downtime_layout.addWidget(duration_clock, 4, 1, 1, 1)
duration_clock.setFixedSize(16, 16)
duration_clock.setScaledContents(True)
self.duration.setTime(QTime(4, 00))
self.duration.setDisplayFormat("HH'h'mm")
downtime_layout.addWidget(self.duration, 4, 2, 1, 1)
duration_info = QLabel(
'<i>Sets the duration if it is a non-fixed downtime.</i>')
downtime_layout.addWidget(duration_info, 5, 0, 1, 3)
date_range_label = QLabel('Downtime date range')
date_range_label.setObjectName('actions')
downtime_layout.addWidget(date_range_label, 6, 0, 1, 1)
calendar_label = QLabel()
calendar_label.setPixmap(QPixmap(get_image_path('calendar')))
calendar_label.setFixedSize(16, 16)
calendar_label.setScaledContents(True)
downtime_layout.addWidget(calendar_label, 6, 1, 1, 1)
start_time_label = QLabel('Start time:')
downtime_layout.addWidget(start_time_label, 7, 0, 1, 1)
self.start_time.setCalendarPopup(True)
self.start_time.setDateTime(datetime.datetime.now())
self.start_time.setDisplayFormat("dd/MM/yyyy HH'h'mm")
downtime_layout.addWidget(self.start_time, 7, 1, 1, 2)
end_time_label = QLabel('End time:')
downtime_layout.addWidget(end_time_label, 8, 0, 1, 1)
self.end_time.setCalendarPopup(True)
self.end_time.setDateTime(datetime.datetime.now() +
datetime.timedelta(hours=2))
self.end_time.setDisplayFormat("dd/MM/yyyy HH'h'mm")
downtime_layout.addWidget(self.end_time, 8, 1, 1, 2)
self.comment_edit.setText(comment)
self.comment_edit.setMaximumHeight(60)
downtime_layout.addWidget(self.comment_edit, 9, 0, 1, 3)
request_btn = QPushButton('REQUEST DOWNTIME', self)
request_btn.clicked.connect(self.handle_accept)
request_btn.setObjectName('valid')
request_btn.setMinimumHeight(30)
request_btn.setDefault(True)
downtime_layout.addWidget(request_btn, 10, 0, 1, 3)
main_layout.addWidget(downtime_widget)
def duration_to_seconds(self):
"""
Return "duration" QTimeEdit value in seconds
:return: "duration" in seconds
:rtype: int
"""
return QTime(0, 0).secsTo(self.duration.time())
def handle_accept(self):
"""
Check if end_time timestamp is not lower than start_time
"""
if self.start_time.dateTime().toTime_t() > self.end_time.dateTime(
).toTime_t():
logger.warning(
'Try to add Downtime with "End Time" lower than "Start Time"')
else:
self.accept()
def mousePressEvent(self, event):
""" QWidget.mousePressEvent(QMouseEvent) """
self.offset = event.pos()
def mouseMoveEvent(self, event):
""" QWidget.mousePressEvent(QMouseEvent) """
try:
x = event.globalX()
y = event.globalY()
x_w = self.offset.x()
y_w = self.offset.y()
self.move(x - x_w, y - y_w)
except AttributeError as e:
logger.warning('Move Event %s: %s', self.objectName(), str(e))
class StartHandicapDialog(QDialog):
def __init__(self):
super().__init__(GlobalAccess().get_main_window())
self.time_format = 'hh:mm:ss'
self.setWindowTitle(_('Handicap start time'))
self.setWindowIcon(QIcon(config.ICON))
self.setSizeGripEnabled(False)
self.setModal(True)
self.layout = QFormLayout(self)
self.handicap_mode = QRadioButton(_('Handicap mode'))
self.reverse_mode = QRadioButton(_('Reverse mode'))
self.layout.addRow(self.handicap_mode)
self.layout.addRow(self.reverse_mode)
self.zero_time_label = QLabel(_('Start time'))
self.zero_time = QTimeEdit()
self.zero_time.setDisplayFormat(self.time_format)
self.layout.addRow(self.zero_time_label, self.zero_time)
self.max_gap_label = QLabel(_('Max gap from leader'))
self.max_gap = QTimeEdit()
self.max_gap.setDisplayFormat(self.time_format)
self.layout.addRow(self.max_gap_label, self.max_gap)
self.second_start_time_label = QLabel(_('Start time for 2 group'))
self.second_time = QTimeEdit()
self.second_time.setDisplayFormat(self.time_format)
self.layout.addRow(self.second_start_time_label, self.second_time)
self.interval_time_label = QLabel(_('Start interval'))
self.interval_time = QTimeEdit()
self.interval_time.setDisplayFormat(self.time_format)
self.layout.addRow(self.interval_time_label, self.interval_time)
self.dsq_offset_label = QLabel(_('Offset after DSQ'))
self.dsq_offset = QTimeEdit()
self.dsq_offset.setDisplayFormat(self.time_format)
self.layout.addRow(self.dsq_offset_label, self.dsq_offset)
def mode_changed():
status = self.handicap_mode.isChecked()
self.max_gap.setEnabled(status)
self.second_time.setEnabled(status)
self.dsq_offset.setDisabled(status)
self.handicap_mode.toggled.connect(mode_changed)
self.reverse_mode.toggled.connect(mode_changed)
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
logging.exception(e)
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
self.layout.addRow(button_box)
self.set_values()
self.show()
def set_values(self):
obj = race()
if obj.get_setting('handicap_mode', True):
self.handicap_mode.toggle()
else:
self.reverse_mode.toggle()
self.zero_time.setTime(
OTime(msec=obj.get_setting('handicap_start',
OTime(0, 11).to_msec())).to_time())
self.max_gap.setTime(
OTime(msec=obj.get_setting('handicap_max_gap',
OTime(0, 0, 30).to_msec())).to_time())
self.second_time.setTime(
OTime(msec=obj.get_setting('handicap_second_start',
OTime(0, 11, 30).to_msec())).to_time())
self.interval_time.setTime(
OTime(msec=obj.get_setting('handicap_interval',
OTime(0, 0, 1).to_msec())).to_time())
self.dsq_offset.setTime(
OTime(msec=obj.get_setting('handicap_dsq_offset',
OTime(0, 0, 10).to_msec())).to_time())
def apply_changes_impl(self):
obj = race()
obj.set_setting('handicap_mode', self.handicap_mode.isChecked())
obj.set_setting('handicap_start',
time_to_otime(self.zero_time.time()).to_msec())
obj.set_setting('handicap_max_gap',
time_to_otime(self.max_gap.time()).to_msec())
obj.set_setting('handicap_second_start',
time_to_otime(self.second_time.time()).to_msec())
obj.set_setting('handicap_interval',
time_to_otime(self.interval_time.time()).to_msec())
obj.set_setting('handicap_dsq_offset',
time_to_otime(self.dsq_offset.time()).to_msec())
if obj.get_setting('handicap_mode', True):
handicap_start_time()
else:
reverse_start_time()
GlobalAccess().get_main_window().refresh()
class MediaCueGeneral(CueGeneral):
Name = 'Cue Settings'
def __init__(self, size, cue=None, parent=None):
super().__init__(size, cue=cue, parent=parent)
# Start at
self.startGroup = QGroupBox(self)
self.startGroup.setLayout(QHBoxLayout())
self.startEdit = QTimeEdit(self.startGroup)
self.startEdit.setDisplayFormat('HH.mm.ss.zzz')
self.startGroup.layout().addWidget(self.startEdit)
self.startLabel = QLabel(self.startGroup)
self.startLabel.setAlignment(QtCore.Qt.AlignCenter)
self.startGroup.layout().addWidget(self.startLabel)
self.layout().addWidget(self.startGroup)
# Loop
self.loopGroup = QGroupBox(self)
self.loopGroup.setLayout(QHBoxLayout())
self.spinLoop = QSpinBox(self.loopGroup)
self.spinLoop.setRange(-1, 1000000)
self.loopGroup.layout().addWidget(self.spinLoop)
self.loopLabel = QLabel(self.loopGroup)
self.loopLabel.setAlignment(QtCore.Qt.AlignCenter)
self.loopGroup.layout().addWidget(self.loopLabel)
self.layout().addWidget(self.loopGroup)
# Checks
self.checkPause = QCheckBox(self)
self.layout().addWidget(self.checkPause)
self.retranslateUi()
def retranslateUi(self):
self.startGroup.setTitle('Start time')
self.startLabel.setText('Amount of skip time')
self.loopGroup.setTitle("Loop")
self.loopLabel.setText("Repetition after first play (-1 = infinite)")
self.checkPause.setText("Enable Pause")
def get_configuration(self):
conf = super().get_configuration()
conf['media'] = {}
checkable = self.startGroup.isCheckable()
if not (checkable and not self.startGroup.isChecked()):
time = self.startEdit.time().msecsSinceStartOfDay()
conf['media']['start_at'] = time
if not (checkable and not self.loopGroup.isChecked()):
conf['media']['loop'] = self.spinLoop.value()
if self.checkPause.checkState() != QtCore.Qt.PartiallyChecked:
conf['pause'] = self.checkPause.isChecked()
return conf
def enable_check(self, enable):
super().enable_check(enable)
self.startGroup.setCheckable(enable)
self.startGroup.setChecked(False)
self.loopGroup.setCheckable(enable)
self.loopGroup.setChecked(False)
self.checkPause.setTristate(enable)
if enable:
self.checkPause.setCheckState(QtCore.Qt.PartiallyChecked)
def set_configuration(self, conf):
super().set_configuration(conf)
if 'pause' in conf:
self.checkPause.setChecked(conf['pause'])
if 'media' in conf:
if 'loop' in conf['media']:
self.spinLoop.setValue(conf['media']['loop'])
if 'duration' in conf['media'] and conf['media']['duration'] > 0:
t = QTime().fromMSecsSinceStartOfDay(conf['media']['duration'])
self.startEdit.setMaximumTime(t)
if 'start_at' in conf['media']:
t = QTime().fromMSecsSinceStartOfDay(conf['media']['start_at'])
self.startEdit.setTime(t)
class MainWindow(PageWindow):
def __init__(self):
super().__init__()
#self.ser = serial.Serial(port='COM3', baudrate=115200, bytesize=8, parity='N', stopbits=1)
self.seperator_vertical = QVSeperationLine()
self.seperator_horizontal = QHSeperationLine()
self.initUI()
self.setWindowTitle("MainWindow")
def initUI(self):
self.homeUI()
def homeUI(self):
self.preview_widget = QWidget()
self.footer_widget = QWidget()
self.home = True
self.viewfinder = QCameraViewfinder()
self.viewfinder.show()
self.setCentralWidget(self.viewfinder)
self.cap = None # -capture <-> +cap
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout2 = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setObjectName("verticalLayout")
self.image_label = QLabel()
self.image_label.setText("")
self.image_label.setObjectName("image_label")
self.temp = QLabel()
self.temp.setText("Temperature:")
self.temp.setObjectName("temp")
self.temp_reading = QLabel()
self.temp_reading.setText("temp_reading")
self.temp_reading.setObjectName("temp_reading")
self.temp2 = QLabel()
self.temp2.setText("Temperature 2:")
self.temp2.setObjectName("temp2")
self.temp2_reading = QLabel()
self.temp2_reading.setText("Temperature2 Reading")
self.temp2_reading.setObjectName("temp2_reading")
self.image_label.setScaledContents(True)
self.matplotlibWidget = MatplotlibWidget(self)
self.threadSample = ThreadSample(self)
self.threadSample.newSample.connect(self.on_threadSample_newSample)
self.threadSample.finished.connect(self.on_threadSample_finished)
self.gridLayout = QGridLayout(self)
self.gridLayout.addWidget(self.temp, 0, 0)
self.gridLayout.addWidget(self.temp_reading, 0, 1)
self.gridLayout.addWidget(self.temp2, 1, 0)
self.gridLayout.addWidget(self.temp2_reading, 1, 1)
self.horizontalLayout.addWidget(self.image_label)
self.horizontalLayout.addWidget(self.seperator_vertical)
self.horizontalLayout.addLayout(self.gridLayout)
self.preview_widget.setLayout(self.horizontalLayout)
self.preview_widget.setMinimumHeight(200)
self.preview_widget.setMaximumHeight(200)
self.preview_widget.setMinimumWidth(600)
self.preview_widget.setMaximumWidth(600)
self.horizontalLayout2.addWidget(self.matplotlibWidget)
self.horizontalLayout2.addWidget(self.seperator_vertical)
#self.horizontalLayout2.addWidget(self.clock)
self.clock(self.horizontalLayout2)
self.footer_widget.setLayout(self.horizontalLayout2)
self.footer_widget.setMinimumHeight(250)
self.footer_widget.setMaximumHeight(250)
self.footer_widget.setMinimumWidth(600)
self.footer_widget.setMaximumWidth(600)
self.verticalLayout.addWidget(self.preview_widget)
self.verticalLayout.addWidget(self.seperator_horizontal)
self.verticalLayout.addWidget(self.footer_widget)
#self.verticalLayout.addWidget(self.image_label2)
self.timer = QTimer(self, interval=5)
self.timer.timeout.connect(self.update_frame)
self._image_counter = 0
centralWidget = QWidget(self)
self.setCentralWidget(centralWidget)
self.centralWidget().setLayout(self.verticalLayout)
# self.setCentralWidget(self.scroll)
self.setGeometry(300, 300, 400, 700)
def read_temp(self):
temp = []
while True:
self.ser.write(b'0x55,0xAA,5,1,4')
response = self.ser.readline()
#print(str(response))
if 'body' in str(response):
temp.append(str(response))
#print("temp-"+str(response))
#print(temp)
elif 'Vbat' in str(response):
if len(temp) != 0:
print("Done-" + ' '.join(temp))
self.start_webcam()
self.update_frame(self.filter(''.join(temp)))
temp = []
def filter(self, text):
text = text.replace('bTbody', 'body')
text = text.replace('\'', '')
text = text.replace('\\r\n\'b\'Tbody', '-')
text = text.replace('\\r', '')
text = text.replace('\r', '')
text = text.replace('\\xa8', '')
text = text.replace('\\xa1\\xe6', '')
text = text.replace('\\n', '-')
text = text.replace(' ', '')
text = text.replace(', ', ',')
text = text.replace('=', '_')
text = text.replace(',', '-')
return text
@QtCore.pyqtSlot()
def start_webcam(self):
if self.cap is None:
self.cap = cv2.VideoCapture(0)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
self.timer.start()
def closeEvent(self, event):
print("closing PyQtTest")
self.cap.close()
@QtCore.pyqtSlot()
def update_frame(self, file_name):
ret, image = self.cap.read()
self.face_detect(image, file_name)
simage = cv2.flip(image, 1)
self.displayImage(image, True)
def face_detect(self, image, file_name):
frame = image
face_locations = []
face_encodings = []
face_names = []
process_this_frame = True
i = 0
face_detect = True
# Resize frame of video to 1/4 size for faster face recognition processing
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_small_frame = small_frame[:, :, ::-1]
self.dirname = 'd:'
# Only process every other frame of video to save time
if process_this_frame:
# Find all the faces and face encodings in the current frame of video
face_locations = face_recognition.face_locations(rgb_small_frame)
face_encodings = face_recognition.face_encodings(
rgb_small_frame, face_locations)
face_names = []
for face_encoding in face_encodings:
# See if the face is a match for the known face(s)
face_detect = False
name = "Unknown"
cv2.imwrite(
os.path.abspath(
os.path.join(
self.dirname,
(datetime.today().strftime('%Y-%m-%d') + '-' +
file_name + '-' + str(++i) + '.png'))), frame)
#self.storage.upload(self.dirname,(datetime.today().strftime('%Y-%m-%d')+'-'+file_name+'-'+str(i)+'.png'))
i = i + 1
print("I see someone named {}!".format(name))
# # If a match was found in known_face_encodings, just use the first one.
# if True in matches:
# first_match_index = matches.index(True)
# name = known_face_names[first_match_index]
# Or instead, use the known face with the smallest distance to the new face
process_this_frame = not process_this_frame
@staticmethod
@QtCore.pyqtSlot()
def capture_image(self):
flag, frame = self.cap.read()
timestamp = time.strftime("%d-%b-%Y-%H_%M_%S")
self.save_seq += 1
path = self.save_path #
if flag:
QtWidgets.QApplication.beep()
name = "my_image.jpg"
cv2.imwrite(
os.path.join(
self.save_path, "%s-%04d-%s.jpg" %
(self.current_camera_name, self.save_seq, timestamp)),
frame)
self._image_counter += 1
def displayImage(self, img, window=True):
qformat = QImage.Format_Indexed8
if len(img.shape) == 3:
if img.shape[2] == 4:
qformat = QImage.Format_RGBA8888
else:
qformat = QImage.Format_RGB888
outImage = QImage(img, img.shape[1], img.shape[0], img.strides[0],
qformat)
outImage = outImage.rgbSwapped()
if window:
self.image_label.setStyleSheet("""
QLabel {
height:300px !important;
}
""")
self.image_label.setPixmap(QPixmap.fromImage(outImage))
def clock(self, layout):
self.verticalLayoutClock = QVBoxLayout(self)
self.dateEdit = QDateEdit(self)
self.dateEdit.setDisplayFormat("MMM dd yyyy")
self.dateEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.dateEdit)
self.timeEdit = QTimeEdit(self)
self.timeEdit.setDisplayFormat("hh:mm:ss AP")
self.timeEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.timeEdit)
self.updateTime()
self.timer = QTimer(self)
self.timer.timeout.connect(self.updateTime)
self.timer.start(1000)
layout.addLayout(self.verticalLayoutClock)
@QtCore.pyqtSlot(list)
def on_threadSample_newSample(self, sample):
self.matplotlibWidget.axis.plot(sample)
self.matplotlibWidget.canvas.draw()
@QtCore.pyqtSlot()
def on_threadSample_finished(self):
self.samples += 1
if self.samples <= 2:
self.threadSample.start()
@QtCore.pyqtSlot()
def on_pushButtonPlot_clicked(self):
self.samples = 0
self.matplotlibWidget.axis.clear()
self.threadSample.start()
def updateTime(self):
current = QtCore.QDateTime.currentDateTime()
self.dateEdit.setDate(current.date())
self.timeEdit.setTime(current.time())
class SeekCueSettings(SettingsPage):
Name = QT_TRANSLATE_NOOP('SettingsPageName', 'Seek Settings')
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout())
self.layout().setAlignment(QtCore.Qt.AlignTop)
self.cue_id = -1
self.cueDialog = CueSelectDialog(
cues=Application().cue_model.filter(MediaCue), parent=self)
self.cueGroup = QGroupBox(self)
self.cueGroup.setLayout(QVBoxLayout())
self.layout().addWidget(self.cueGroup)
self.cueButton = QPushButton(self.cueGroup)
self.cueButton.clicked.connect(self.select_cue)
self.cueGroup.layout().addWidget(self.cueButton)
self.cueLabel = QLabel(self.cueGroup)
self.cueLabel.setAlignment(QtCore.Qt.AlignCenter)
self.cueGroup.layout().addWidget(self.cueLabel)
self.seekGroup = QGroupBox(self)
self.seekGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.seekGroup)
self.seekEdit = QTimeEdit(self.seekGroup)
self.seekEdit.setDisplayFormat('HH.mm.ss.zzz')
self.seekGroup.layout().addWidget(self.seekEdit)
self.seekLabel = QLabel(self.seekGroup)
self.seekLabel.setAlignment(QtCore.Qt.AlignCenter)
self.seekGroup.layout().addWidget(self.seekLabel)
self.retranslateUi()
def retranslateUi(self):
self.cueGroup.setTitle(translate('SeekCue', 'Cue'))
self.cueButton.setText(translate('SeekCue', 'Click to select'))
self.cueLabel.setText(translate('SeekCue', 'Not selected'))
self.seekGroup.setTitle(translate('SeekCue', 'Seek'))
self.seekLabel.setText(translate('SeekCue', 'Time to reach'))
def select_cue(self):
if self.cueDialog.exec_() == self.cueDialog.Accepted:
cue = self.cueDialog.selected_cue()
if cue is not None:
self.cue_id = cue.id
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
def enable_check(self, enabled):
self.cueGroup.setCheckable(enabled)
self.cueGroup.setChecked(False)
self.seekGroup.setCheckable(enabled)
self.seekGroup.setChecked(False)
def get_settings(self):
return {
'target_id': self.cue_id,
'time': self.seekEdit.time().msecsSinceStartOfDay()
}
def load_settings(self, settings):
if settings is not None:
cue = Application().cue_model.get(settings.get('target_id'))
if cue is not None:
self.cue_id = settings['target_id']
self.seekEdit.setMaximumTime(
QTime.fromMSecsSinceStartOfDay(cue.media.duration))
self.cueLabel.setText(cue.name)
self.seekEdit.setTime(
QTime.fromMSecsSinceStartOfDay(settings.get('time', 0)))
class TimeItem(QListWidgetItem):
def __init__(self, parent=None, *args, **kwargs):
super().__init__(parent)
self.parent = parent
def setupUi(self, *args, **kwargs):
self.widget = QWidget()
try:
self.setSizeHint(QSize(self.parent.width() - 20, 40))
self.widget.setGeometry(
QtCore.QRect(0, 0,
self.parent.width() - 20, 40))
except Exception as e:
logging.warning(e)
self.setSizeHint(QSize(80, 60))
self.widget.setObjectName("Form")
self.horizontalLayoutWidget = QtWidgets.QWidget(self.widget)
self.horizontalLayoutWidget.setGeometry(
QtCore.QRect(10, 0,
self.widget.width() - 10, self.widget.height()))
self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget")
self.horizontalLayout = QtWidgets.QHBoxLayout(
self.horizontalLayoutWidget)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.radioButton = QtWidgets.QRadioButton(self.horizontalLayoutWidget)
self.radioButton.setObjectName("radioButton")
self.radioButton.setText('禁用')
self.horizontalLayout.addWidget(self.radioButton)
self.lineEdit = QtWidgets.QLineEdit(self.horizontalLayoutWidget)
self.lineEdit.setObjectName("lineEdit")
self.lineEdit.setText('abc')
self.horizontalLayout.addWidget(self.lineEdit)
self.comboBox = QtWidgets.QComboBox(self.horizontalLayoutWidget)
self.comboBox.setObjectName("comboBox")
self.comboBoxSel = {'间隔': "interval", '周期': 'cron', '仅一次': 'date'}
for sel in self.comboBoxSel:
self.comboBox.addItem(sel)
self.horizontalLayout.addWidget(self.comboBox)
self.timeEdit = QTimeEdit(self.horizontalLayoutWidget)
self.timeEdit.setObjectName("timeEdit")
self.timeEdit.setDisplayFormat('hh:mm:ss')
self.horizontalLayout.addWidget(self.timeEdit)
QtCore.QMetaObject.connectSlotsByName(self.widget)
# 设置配置
try:
self.set_data(info=kwargs['info'])
except Exception as e:
self.set_data(info=None)
# 设置交互
self.set_connect()
return self.widget
def set_data(self, *args, **kwargs):
if 'info' in kwargs.keys() and kwargs['info']:
self.info = kwargs['info']
else:
self.info = {
"id": "luck",
"trigger": "interval",
"time": 3600,
"is_action": False,
"mission_name": 'new mission'
}
self.set_ui()
def set_ui(self):
try:
self.radioButton.setChecked(self.info['is_action'])
self.radio_check()
self.lineEdit.setText(self.info['mission_name'])
index = list(self.comboBoxSel.values()).index(self.info['trigger'])
self.comboBox.setCurrentIndex(index)
# to do
if 'interval' == self.info['trigger']:
self.timeEdit.setTime(QTime(0, 0).addSecs(self.info['time']))
elif 'date' == self.info['trigger']:
logging.warning('暂不支持 date 设置')
elif 'cron' == self.info['trigger']:
logging.warning('暂不支持 cron 设置')
except Exception as e:
logging.warning(e)
def update_info(self) -> bool:
flag = False
if 'luck' == self.info['id']:
self.info['id'] = cryptograph_text(str(int(time.time())))
index = self.comboBox.currentIndex()
self.info['trigger'] = list(self.comboBoxSel.values())[index]
self.info['is_action'] = self.radioButton.isChecked()
self.info['mission_name'] = self.lineEdit.text()
aps_time = self.timeEdit.time()
self.info['time'] = aps_time.hour() * 3600 + aps_time.minute(
) * 60 + aps_time.second()
# 新任务无sign
if 'sign' not in self.info.keys():
self.info['createtime'] = get_full_datetime()
self.info['sign'] = cryptograph_text(
json.dumps(self.info, ensure_ascii=False))
flag = True
# 旧任务重新校验
else:
sign = self.info.pop('sign')
if sign != cryptograph_text(
json.dumps(self.info, ensure_ascii=False)):
self.info['sign'] = cryptograph_text(
json.dumps(self.info, ensure_ascii=False))
flag = True
else:
self.info['sign'] = sign
return flag
def set_connect(self):
self.radioButton.clicked.connect(self.radio_check)
def radio_check(self):
if self.radioButton.isChecked():
self.radioButton.setStyleSheet('QRadioButton{color:green}')
self.radioButton.setText('启用')
else:
self.radioButton.setStyleSheet('QRadioButton{color:red}')
self.radioButton.setText('禁用')
class MediaCueSettings(SettingsPage):
Name = 'Media-Cue'
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.setLayout(QVBoxLayout(self))
# Start time
self.startGroup = QGroupBox(self)
self.startGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.startGroup)
self.startEdit = QTimeEdit(self.startGroup)
self.startEdit.setDisplayFormat('HH.mm.ss.zzz')
self.startGroup.layout().addWidget(self.startEdit)
self.startLabel = QLabel(self.startGroup)
self.startLabel.setAlignment(Qt.AlignCenter)
self.startGroup.layout().addWidget(self.startLabel)
# Stop time
self.stopGroup = QGroupBox(self)
self.stopGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.stopGroup)
self.stopEdit = QTimeEdit(self.stopGroup)
self.stopEdit.setDisplayFormat('HH.mm.ss.zzz')
self.stopGroup.layout().addWidget(self.stopEdit)
self.stopLabel = QLabel(self.stopGroup)
self.stopLabel.setAlignment(Qt.AlignCenter)
self.stopGroup.layout().addWidget(self.stopLabel)
# Loop
self.loopGroup = QGroupBox(self)
self.loopGroup.setLayout(QHBoxLayout())
self.layout().addWidget(self.loopGroup)
self.spinLoop = QSpinBox(self.loopGroup)
self.spinLoop.setRange(-1, 1000000)
self.loopGroup.layout().addWidget(self.spinLoop)
self.loopLabel = QLabel(self.loopGroup)
self.loopLabel.setAlignment(Qt.AlignCenter)
self.loopGroup.layout().addWidget(self.loopLabel)
self.retranslateUi()
def retranslateUi(self):
self.startGroup.setTitle(translate('MediaCueSettings', 'Start time'))
self.stopLabel.setText(
translate('MediaCueSettings', 'Stop position of the media'))
self.stopGroup.setTitle(translate('MediaCueSettings', 'Stop time'))
self.startLabel.setText(
translate('MediaCueSettings', 'Start position of the media'))
self.loopGroup.setTitle(translate('MediaCueSettings', 'Loop'))
self.loopLabel.setText(
translate('MediaCueSettings', 'Repetition after first play '
'(-1 = infinite)'))
def get_settings(self):
conf = {'_media_': {}}
checkable = self.startGroup.isCheckable()
if not (checkable and not self.startGroup.isChecked()):
time = self.startEdit.time().msecsSinceStartOfDay()
conf['_media_']['start_time'] = time
if not (checkable and not self.stopGroup.isChecked()):
time = self.stopEdit.time().msecsSinceStartOfDay()
conf['_media_']['stop_time'] = time
if not (checkable and not self.loopGroup.isChecked()):
conf['_media_']['loop'] = self.spinLoop.value()
return conf
def enable_check(self, enable):
self.startGroup.setCheckable(enable)
self.startGroup.setChecked(False)
self.stopGroup.setCheckable(enable)
self.stopGroup.setChecked(False)
self.loopGroup.setCheckable(enable)
self.loopGroup.setChecked(False)
def load_settings(self, settings):
if '_media_' in settings:
if 'loop' in settings['_media_']:
self.spinLoop.setValue(settings['_media_']['loop'])
if 'start_time' in settings['_media_']:
t = self._to_qtime(settings['_media_']['start_time'])
self.startEdit.setTime(t)
if 'stop_time' in settings['_media_']:
t = self._to_qtime(settings['_media_']['stop_time'])
self.stopEdit.setTime(t)
t = self._to_qtime(settings['_media_'].get('duration', 0))
self.startEdit.setMaximumTime(t)
self.stopEdit.setMaximumTime(t)
def _to_qtime(self, m_seconds):
return QTime.fromMSecsSinceStartOfDay(m_seconds)
class FrameSelectWidget(QWidget):
frameSelectionChanged = pyqtSignal(int, QTime)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setMaximumWidth(960)
layout = QVBoxLayout()
layout.setContentsMargins(4, 4, 4, 4)
layout.setSpacing(4)
self.setLayout(layout)
self.imageView = QImageView(self)
layout.addWidget(self.imageView)
self.slider = Slider(self)
self.slider.setOrientation(Qt.Horizontal)
self.slider.valueChanged.connect(self.handleSliderChange)
self.slider.setTickInterval(1)
layout.addWidget(self.slider)
hlayout = QHBoxLayout()
layout.addLayout(hlayout)
self.prevLabel = QLabel(self)
self.currentIndex = QSpinBox(self)
self.currentIndex.valueChanged.connect(self.handleIndexChange)
self.currentTime = QTimeEdit(self)
self.currentTime.setDisplayFormat("H:mm:ss.zzz")
self.currentTime.timeChanged.connect(self.handleTimeChange)
self.nextLabel = QLabel(self)
hlayout.addWidget(self.prevLabel)
hlayout.addStretch()
hlayout.addWidget(QLabel("Frame index:", self))
hlayout.addWidget(self.currentIndex)
hlayout.addWidget(QLabel("Timestamp:", self))
hlayout.addWidget(self.currentTime)
hlayout.addStretch()
hlayout.addWidget(self.nextLabel)
hlayout = QHBoxLayout()
hlayout.setContentsMargins(0, 0, 0, 0)
hlayout.setSpacing(4)
layout.addLayout(hlayout)
self.okayBtn = QPushButton("&OK", self)
self.cancelBtn = QPushButton("&Cancel", self)
hlayout.addStretch()
hlayout.addWidget(self.okayBtn)
hlayout.addWidget(self.cancelBtn)
self.setFrameSource(None, None)
def sizeHint(self):
widgetHeights = (
self.slider.height()
+ max([self.okayBtn.height(), self.cancelBtn.height()])
+ max([self.currentIndex.height(), self.currentTime.height()])
)
if isinstance(self.filters, BaseFilter):
w, h = self.filters.width, self.filters.height
sar = self.filters.sar
elif isinstance(self.source, (Track, BaseFilter)):
w, h = self.source.width, self.source.height
sar = self.source.sar
else:
return super().sizeHint()
dar = w*sar/h
W, H = min([
max([(w, h/sar), (w*sar, h)]),
(960 - 8, (960 - 8)/dar),
((720 - 20 - widgetHeights)*dar, 720 - 20 - widgetHeights)
])
return QSize(int(W + 8), int(H + 20 + widgetHeights))
def setFrameSource(self, source, filters=None):
self.source = source
if source is not None:
self.slider.setMaximum(self.source.framecount - 1)
self.currentIndex.setMaximum(self.source.framecount - 1)
self.filters = filters
if self.filters is not None:
lastpts = self.filters.pts_time[-1]
self.slider.setSnapValues(self.filters.keyframes)
else:
lastpts = self.source.pts_time[-1]
if isinstance(self.source, BaseFilter):
self.slider.setSnapValues(self.source.keyframes)
else:
self.slider.setSnapValues(None)
ms = int(lastpts*1000 + 0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
self.currentTime.setMaximumTime(QTime(h, m, s, ms))
self.slider.setValue(0)
self._frameChange(0)
else:
self.slider.setSnapValues(None)
self.update()
def handleIndexChange(self, n):
self._frameChange(n)
self.slider.blockSignals(True)
self.slider.setValue(n)
self.slider.blockSignals(False)
def handleSliderChange(self, n):
self._frameChange(n)
self.currentIndex.blockSignals(True)
self.currentIndex.setValue(n)
self.currentIndex.blockSignals(False)
def _frameChange(self, n):
if self.source is not None:
if self.filters is not None:
nn = n
m = -1
while m < 0 and nn < len(self.filters.indexMap):
m = self.filters.indexMap[nn]
nn += 1
try:
pts = self.filters.pts_time[m]
except Exception:
pts = None
try:
frame = next(self.filters.iterFrames(
m, whence="framenumber"))
except StopIteration:
frame = None
sar = self.filters.sar
else:
try:
pts = self.source.pts_time[n]
except IndexError:
pts = None
try:
frame = next(self.source.iterFrames(
n, whence="framenumber"))
except StopIteration:
frame = None
sar = self.source.sar
if frame is not None:
im = frame.to_image()
self.imageView.setFrame(im.toqpixmap())
self.imageView.setSar(sar)
if pts is not None:
ms = int(pts*1000+0.5)
s, ms = divmod(ms, 1000)
m, s = divmod(s, 60)
h, m = divmod(m, 60)
self.currentTime.blockSignals(True)
self.currentTime.setTime(QTime(h, m, s, ms))
self.currentTime.blockSignals(False)
self.frameSelectionChanged.emit(n, self.currentTime.time())
def handleTimeChange(self, t):
if self.source is not None:
if self.filters is not None:
pts = t.msecsSinceStartOfDay()/1000
n = self.filters.frameIndexFromPtsTime(pts, dir="-")
else:
pts = t.msecsSinceStartOfDay()/1000
n = self.source.frameIndexFromPtsTime(pts, dir="-")
self.slider.blockSignals(True)
self.slider.setValue(n)
self.slider.blockSignals(False)
self.currentIndex.blockSignals(True)
self.currentIndex.setValue(n)
self.currentIndex.blockSignals(False)
self._frameChange(n)
class MainWindow(PageWindow):
def __init__(self, dir):
super().__init__()
self.storage = firebase.screening()
try:
self.ser = serial.Serial(port='COM3',
baudrate=115200,
bytesize=8,
parity='N',
stopbits=1)
except Exception as ex:
message = template.format(type(ex).__name__, ex.args)
print(message)
self.dirname = dir
self.seperator_vertical = QVSeperationLine()
self.seperator_horizontal = QHSeperationLine()
self.initUI()
self.setWindowTitle("MainWindow")
self.overlay = Overlay(self.centralWidget())
self.available_cameras = QCameraInfo.availableCameras()
if not self.available_cameras:
pass #quit
self.select_camera(0)
def initUI(self):
self.homeUI()
def homeUI(self):
self.preview_widget = QWidget()
self.footer_widget = QWidget()
self.grid_widget = QWidget()
self.graph_widget = QWidget()
self.home = True
self.viewfinder = QCameraViewfinder()
self.viewfinder.show()
self.setCentralWidget(self.viewfinder)
self.cap = None # -capture <-> +cap
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout2 = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.verticalLayout = QVBoxLayout()
self.chartLayout = QVBoxLayout()
self.verticalLayout.setObjectName("verticalLayout")
self.image_label = QLabel()
self.image_label.setText("")
self.image_label.setObjectName("image_label")
self.image_label.setStyleSheet("QLabel { margin-right:4px; }")
self.temp = QLabel()
self.temp.setText("TEMPERATURE : ")
self.temp.setObjectName("temp")
self.temp.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
#self.temp.setAlignment(QtCore.Qt.AlignCenter)
self.temp_reading = QLabel()
self.temp_reading.setText("READING...")
self.temp_reading.setObjectName("temp_reading")
self.temp_reading.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
#self.temp_reading.setAlignment(QtCore.Qt.AlignCenter)
self.temp2 = QLabel()
self.temp2.setText("ROOM READING : ")
self.temp2.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
self.temp2.setObjectName("temp2")
#self.temp2.setAlignment(QtCore.Qt.AlignCenter)
self.temp2_reading = QLabel()
self.temp2_reading.setText("READING...")
self.temp2_reading.setFont(QFont("Gadugi", 15, weight=QFont.Bold))
#self.temp2_reading.setAlignment(QtCore.Qt.AlignCenter)
self.temp2_reading.setObjectName("temp2_reading")
self.image_label.setScaledContents(True)
self.matplotlibWidget = MatplotlibWidget(self)
self.threadSample = ThreadSample(self)
self.threadSample.newSample.connect(self.on_threadSample_newSample)
self.threadSample.finished.connect(self.on_threadSample_finished)
self.gridLayout = QGridLayout(self)
self.gridLayout.addWidget(self.temp, 0, 0, 1, 1)
self.gridLayout.addWidget(self.temp_reading, 0, 1, 1, 3)
self.gridLayout.addWidget(self.temp2, 2, 0, 1, 1)
self.gridLayout.addWidget(self.temp2_reading, 2, 1, 1, 3)
self.clock(self.gridLayout, 3, 0, 3, 3)
self.grid_widget.setLayout(self.gridLayout)
self.grid_widget.setMinimumHeight(250)
self.grid_widget.setMaximumHeight(250)
self.grid_widget.setMinimumWidth(600)
self.grid_widget.setMaximumWidth(600)
self.horizontalLayout.addWidget(self.image_label)
#self.horizontalLayout.addWidget(self.seperator_vertical)
self.horizontalLayout.addWidget(self.graph_widget)
self.preview_widget.setLayout(self.horizontalLayout)
self.preview_widget.setMinimumHeight(200)
self.preview_widget.setMaximumHeight(200)
self.preview_widget.setMinimumWidth(600)
self.preview_widget.setMaximumWidth(600)
# self.chartLayout.addWidget(self.matplotlibWidget)
# self.graph_widget.setLayout(self.chartLayout)
self.graph_widget.setMinimumHeight(250)
self.graph_widget.setMaximumHeight(250)
self.graph_widget.setMinimumWidth(250)
self.graph_widget.setMaximumWidth(250)
self.horizontalLayout2.addWidget(self.grid_widget)
# self.horizontalLayout2.addWidget(self.seperator_vertical)
#self.horizontalLayout2.addWidget(self.clock)
#self.clock(self.horizontalLayout2)
self.footer_widget.setLayout(self.horizontalLayout2)
self.footer_widget.setMinimumHeight(250)
self.footer_widget.setMaximumHeight(250)
self.footer_widget.setMinimumWidth(600)
self.footer_widget.setMaximumWidth(600)
self.verticalLayout.addWidget(self.preview_widget)
self.verticalLayout.addWidget(self.seperator_horizontal)
self.verticalLayout.addWidget(self.footer_widget)
#self.verticalLayout.addWidget(self.image_label2)
self.timer = QTimer(self, interval=5)
self.timer.timeout.connect(self.update_frame)
self._image_counter = 0
centralWidget = QWidget(self)
self.setCentralWidget(centralWidget)
self.centralWidget().setLayout(self.verticalLayout)
self.start_webcam()
self.update_frame()
# self.setCentralWidget(self.scroll)
self.setGeometry(300, 300, 400, 700)
thread = Thread(target=self.read_temp)
thread.daemon = True
thread.start()
def select_camera(self, i):
self.camera = QCamera(self.available_cameras[i])
self.camera.setViewfinder(self.viewfinder)
self.camera.setCaptureMode(QCamera.CaptureStillImage)
self.camera.error.connect(
lambda: self.alert(self.camera.errorString()))
self.camera.start()
self.capture = QCameraImageCapture(self.camera)
self.capture.error.connect(lambda i, e, s: self.alert(s))
self.capture.imageCaptured.connect(lambda d, i: self.statusmessage(
"Image %04d captured" % self.save_seq))
self.current_camera_name = self.available_cameras[i].description()
self.save_seq = 0
def read_temp(self):
temp = []
while True:
self.ser.write(b'0x55,0xAA,5,1,4')
response = self.ser.readline()
print(str(response))
if 'body' in str(response):
temp.append(str(response))
#print("temp-"+str(response))
#print(temp)
elif 'Vbat' in str(response):
if len(temp) != 0:
temp[1] = temp[1].replace('b\'T body =', '')
temp[1] = temp[1].replace("\\r\\n'", '')
temp[0] = temp[0].replace('b\'T body =', '')
temp[0] = temp[0].replace("compensate\\r\\n'", '')
self.findFaces('-'.join(temp))
self.update_label(temp[0], temp[1], '12')
temp = []
time.sleep(1)
# start = time.clock()
# while True:
# if True:
# if True:
# temp.append(str(random.randint(0,100)))
# temp.append(str(random.randint(0,100)))
# self.overlay.show()
# self.findFaces('-'.join(temp))
# self.update_label(temp[0],temp[1],'12')
# self.overlay.hide()
# print("Done-"+ ' '.join(temp))
# temp = []
# time.sleep(1)
def statusmessage(self, msg):
self.statusBar().showMessage(msg)
def update_label(self, temp1, temp2, time):
print(temp1)
temp2 = self.getTemp(str(temp2))
temp1 = self.getTemp(str(temp1))
if temp2 >= 36.1 and temp2 <= 37.2:
pal = self.temp_reading.palette()
pal.setColor(QPalette.WindowText, QColor("green"))
self.temp_reading.setPalette(pal)
else:
pal = self.temp_reading.palette()
pal.setColor(QPalette.WindowText, QColor("red"))
self.temp_reading.setPalette(pal)
# if temp2>=36.1 and temp2<=37.2:
# pal = self.temp_reading.palette()
# pal.setColor(QPalette.WindowText, QColor("black"))
# self.temp2_reading.setPalette(pal)
# else:
# pal = self.temp_reading.palette()
# pal.setColor(QPalette.WindowText, QColor("black"))
# self.temp2_reading.setPalette(pal)
self.temp_reading.setText(str(temp2) + " °C")
self.temp2_reading.setText(str(temp1) + " °C")
#self.temp2_reading.setColor(QPalette.WindowText, QtGui.QColor("red"))
def getTemp(self, inp):
temp = re.findall(r"[-+]?\d*\.\d+|\d+", inp)
temp = ''.join(temp)
if temp == '':
return 0
else:
return float(temp)
def filter(self, text):
text = text.replace('bTbody', 'body')
text = text.replace('\'', '')
text = text.replace('\\r\n\'b\'Tbody', '-')
text = text.replace('\\r', '')
text = text.replace('\r', '')
text = text.replace('\\xa8', '')
text = text.replace('\\xa1\\xe6', '')
text = text.replace('\\n', '-')
text = text.replace(' ', '')
text = text.replace(', ', ',')
text = text.replace('=', '_')
text = text.replace(',', '-')
return text
def alert(self, s):
"""
Handle errors coming from QCamera dn QCameraImageCapture by displaying alerts.
"""
err = QErrorMessage(self)
err.showMessage(s)
@QtCore.pyqtSlot()
def start_webcam(self):
if self.cap is None:
self.cap = cv2.VideoCapture(0)
self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
self.timer.start()
def start_cam(self):
self.cap.open(0)
def stop_webcam(self):
self.cap.release()
def closeEvent(self, event):
print("closing PyQtTest")
self.cap.close()
@QtCore.pyqtSlot()
def update_frame(self):
if self.cap.isOpened():
ret, image = self.cap.read()
#self.face_detect(image,file_name)
simage = cv2.flip(image, 1)
self.displayImage(image, True)
def findFaces(self, file_name):
face_detect = True
while face_detect:
if self.cap.isOpened():
ret, frame = self.cap.read()
face_locations = fl(frame)
print("I found {} face(s) in this photograph.".format(
len(face_locations)))
#self.statusmessage("I found {} face(s) in this photograph.".format(len(face_locations)))
for face_location in face_locations:
face_detect = False
# Print the location of each face in this image
top, right, bottom, left = face_location
print(
"A face is located at pixel location Top: {}, Left: {}, Bottom: {}, Right: {}"
.format(top, left, bottom, right))
# ts = time.time()
# You can access the actual face itself like this:
face_image = frame[top - 100:bottom + 100,
left - 100:right + 100]
ts = datetime.now().strftime('%Y_%m_%d-%H_%M_%S')
cv2.imwrite(
os.path.abspath(
os.path.join(self.dirname,
(ts + '-' + file_name + '.jpg'))),
face_image)
self.storage.upload(self.dirname,
(ts + '-' + file_name + '.jpg'))
def face_detect(self, file_name):
face_locations = []
face_encodings = []
face_names = []
process_this_frame = True
i = 0
face_detect = True
# Resize frame of video to 1/4 size for faster face recognition processing
while face_detect:
ret, frame = self.cap.read()
#self.face_detect(image,file_name)
#simage = cv2.flip(image, 1)
small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
# Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses)
rgb_small_frame = small_frame[:, :, ::-1]
# Only process every other frame of video to save time
if process_this_frame:
# Find all the faces and face encodings in the current frame of video
face_locations = face_recognition.face_locations(
rgb_small_frame)
face_encodings = face_recognition.face_encodings(
rgb_small_frame, face_locations)
face_names = []
for face_encoding in face_encodings:
# See if the face is a match for the known face(s)
face_detect = False
name = "Unknown"
cv2.imwrite(
os.path.abspath(
os.path.join(
self.dirname,
(datetime.today().strftime('%Y-%m-%d') + '-' +
file_name + '-' + str(++i) + '.png'))), frame)
#self.storage.upload(self.dirname,(datetime.today().strftime('%Y-%m-%d')+'-'+file_name+'-'+str(i)+'.png'))
i = i + 1
print("I see someone named {}!".format(name))
# # If a match was found in known_face_encodings, just use the first one.
# if True in matches:
# first_match_index = matches.index(True)
# name = known_face_names[first_match_index]
# Or instead, use the known face with the smallest distance to the new face
process_this_frame = not process_this_frame
@QtCore.pyqtSlot()
def capture_image(self):
if self.cap.isOpened():
flag, frame = self.cap.read()
timestamp = time.strftime("%d-%b-%Y-%H_%M_%S")
self.save_seq += 1
path = self.dirname #
if flag:
QtWidgets.QApplication.beep()
name = "my_image.jpg"
cv2.imwrite(
os.path.join(
self.dirname, "%s-%04d-%s.jpg" %
(self.current_camera_name, self.save_seq, timestamp)),
frame)
self.alert('Image Store Successfully.')
self._image_counter += 1
def displayImage(self, img, window=True):
qformat = QImage.Format_Indexed8
if len(img.shape) == 3:
if img.shape[2] == 4:
qformat = QImage.Format_RGBA8888
else:
qformat = QImage.Format_RGB888
outImage = QImage(img, img.shape[1], img.shape[0], img.strides[0],
qformat)
outImage = outImage.rgbSwapped()
if window:
self.image_label.setStyleSheet("""
QLabel {
height:300px !important;
}
""")
self.image_label.setPixmap(QPixmap.fromImage(outImage))
def clock(self, layout, row, col, row_span, col_span):
self.verticalLayoutClock = QVBoxLayout(self)
self.dateEdit = QDateEdit(self)
self.dateEdit.setDisplayFormat("MMM dd yyyy")
self.dateEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.dateEdit)
self.timeEdit = QTimeEdit(self)
self.timeEdit.setDisplayFormat("hh:mm:ss AP")
self.timeEdit.setDisabled(True)
self.verticalLayoutClock.addWidget(self.timeEdit)
self.updateTime()
self.timer = QTimer(self)
self.timer.timeout.connect(self.updateTime)
self.timer.start(1000)
layout.addLayout(self.verticalLayoutClock, row, col, row_span,
col_span)
@QtCore.pyqtSlot(list)
def on_threadSample_newSample(self, sample):
self.matplotlibWidget.axis.plot(sample)
self.matplotlibWidget.canvas.draw()
@QtCore.pyqtSlot()
def on_threadSample_finished(self):
self.samples += 1
if self.samples <= 2:
self.threadSample.start()
@QtCore.pyqtSlot()
def on_pushButtonPlot_clicked(self):
self.samples = 0
self.matplotlibWidget.axis.clear()
self.threadSample.start()
def updateTime(self):
current = QtCore.QDateTime.currentDateTime()
self.dateEdit.setDate(current.date())
self.timeEdit.setTime(current.time())
class TaskView(QWidget):
close = pyqtSignal()
def __init__(self, model):
super().__init__()
self.header = QLabel('')
self.desc = QLineEdit()
self.date = QDateEdit()
self.time = QTimeEdit()
self.init_ui()
self.mapper = QDataWidgetMapper()
self.mapper.setModel(model)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.addMapping(self.desc, TaskModel.col_desc)
self.mapper.addMapping(self.date, TaskModel.col_date)
self.mapper.addMapping(self.time, TaskModel.col_time)
def set_task(self, index):
self.mapper.setCurrentIndex(index)
self.header.setText('РЕДАКТИРОВАНИЕ ЗАДАЧИ')
# text = 'НОВАЯ ЗАДАЧА'
# self.date.setDate(QDate().currentDate())
def create_date(self):
self.date.setDisplayFormat('dd.MM.yyyy')
self.date.setCalendarPopup(True)
self.date.setFixedWidth(120)
return self.date
def create_time(self):
self.time.setDisplayFormat('hh.mm')
self.time.setFixedWidth(120)
return self.time
def create_date_buttons(self):
date_lt = QHBoxLayout()
btn_now = QPushButton('сегодня')
btn_now.clicked.connect(lambda: self.date.setDate(QDate().currentDate()))
date_lt.addWidget(btn_now, 0, Qt.AlignCenter)
btn_tomorrow = QPushButton('завтра')
btn_tomorrow.clicked.connect(lambda: self.date.setDate(QDate().currentDate().addDays(1)))
date_lt.addWidget(btn_tomorrow, 0, Qt.AlignCenter)
btn_week_later = QPushButton('через неделю')
btn_week_later.clicked.connect(lambda: self.date.setDate(QDate().currentDate().addDays(7)))
date_lt.addWidget(btn_week_later, 0, Qt.AlignCenter)
return date_lt
# def create_time_choice(self):
# self.time.setMaxVisibleItems(15)
# self.time.setStyleSheet('QComboBox { combobox-popup: 0; }')
# for it in range(24):
# self.time.insertItem(it * 2 + 0, '%.2d:00' % it)
# self.time.insertItem(it * 2 + 1, '%.2d:30' % it)
#
# return self.time
def save(self):
print('save', self.mapper.submit())
self.close.emit()
def cancel(self):
self.close.emit()
def remove(self):
self.mapper.model().removeRow(self.mapper.currentIndex())
self.close.emit()
def create_control_buttons(self):
control_lt = QHBoxLayout()
btn_save = QPushButton('Сохранить')
btn_save.clicked.connect(self.save)
control_lt.addWidget(btn_save, 0, Qt.AlignCenter)
btn_cancel = QPushButton('Отменить')
btn_cancel.clicked.connect(self.cancel)
control_lt.addWidget(btn_cancel, 0, Qt.AlignCenter)
btn_remove = QPushButton('Удалить')
btn_remove.clicked.connect(self.remove)
control_lt.addWidget(btn_remove, 1, Qt.AlignRight)
return control_lt
def create_main_form(self):
fm = QFormLayout()
fm.addRow(self.header)
fm.addRow(QLabel(''))
fm.addRow(self.desc)
fm.addRow(QLabel(''))
fm.addRow(QLabel('Когда это нужно сделать?'))
fm.addRow(self.create_date())
fm.addRow(self.create_date_buttons())
fm.addRow(QLabel(''))
fm.addRow(QLabel('Во сколько?'))
fm.addRow(self.create_time())
return fm
def init_ui(self):
layout = QVBoxLayout()
layout.addLayout(self.create_main_form())
layout.addStretch()
layout.addLayout(self.create_control_buttons())
self.setLayout(layout)
