if filename[-3:] == 'qml' and 'IN_MODIFY' in type_names:
reload = True
break
if reload:
self.requestReload.emit()
if __name__ == "__main__":
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
workerThread = QThread()
workerThread.start()
worker = Worker()
worker.moveToThread(workerThread)
master = Master()
master.command.connect(worker.run)
worker.requestReload.connect(master.reload)
master.command.emit()
# Stop application gracefully:
signal.signal(signal.SIGINT, signal.SIG_DFL)
status = app.exec_()
worker.stop()
workerThread.quit()
workerThread.wait()
sys.exit(status)
class App(QWidget):
def __init__(self):
super(App, self).__init__()
self.combo = None
self.MainProcess = MainProcess()
self.MainProcess.get_image_functions()
self.fps_label = QLabel('FPS: XXX')
self.initUI()
self._thread = QThread(self)
self.video_worker = VideoThread(self.MainProcess.list_of_filters)
#self.combo.currentIndexChanged.connect(self.video_worker.new_filter_slot)
self.combo.currentIndexChanged.connect(self._new_ind)
self.video_worker.change_pixmap_signal.connect(self.update_image)
self.video_worker.update_fps_signal.connect(self._new_fps)
self.video_worker.moveToThread(self._thread)
self.combo.setCurrentIndex(self.MainProcess.blank_index)
# connect the buttons
self.start_button.clicked.connect(self.video_worker.start)
self.quit_button.clicked.connect(
self.close) # force this to run on current thread
self._thread.start()
@Slot()
def _new_ind(self, ind):
self.video_worker.new_filter_slot(ind)
@Slot(int)
def _new_fps(self, fps):
self.fps_label.setText(f'FPS: {fps:.1f}')
def initUI(self):
self.cam = CamImage()
self.start_button = QPushButton("Start")
self.quit_button = QPushButton("Quit")
controls = ControlWidget()
self.combo = QComboBox(self)
for it in self.MainProcess.list_of_filters:
self.combo.addItem(it[0])
hbox = QHBoxLayout()
hbox.addWidget(controls)
hbox.addStretch(1)
hbuttons = QHBoxLayout()
hbuttons.addWidget(self.combo)
hbuttons.addWidget(self.start_button)
hbuttons.addWidget(self.quit_button)
vbutton = QVBoxLayout()
vbutton.addLayout(hbuttons)
vbutton.addWidget(self.fps_label)
hbox.addLayout(vbutton)
vbox = QVBoxLayout()
vbox.addWidget(self.cam)
vbox.addStretch(1)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.setGeometry(300, 300, 300, 150)
self.setWindowTitle('Buttons')
self.show()
def closeEvent(self, event):
logger.debug('Got Close Event')
self.video_worker.stop()
self._thread.wait()
event.accept()
@Slot(np.ndarray)
def update_image(self, cv_img):
"""Updates the image_label with a new opencv image"""
qt_img = self.convert_cv_qt(cv_img)
self.cam.setPixmap(qt_img)
def convert_cv_qt(self, cv_img):
"""Convert from an opencv image to QPixmap"""
rgb_image = cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB)
h, w, ch = rgb_image.shape
bytes_per_line = ch * w
convert_to_Qt_format = QImage(rgb_image.data, w, h, bytes_per_line,
QImage.Format_RGB888)
p = convert_to_Qt_format.scaled(self.cam.width(), self.cam.height(),
Qt.KeepAspectRatio)
return QPixmap.fromImage(p)
class EvelynDesktop(QStackedWidget):
INTERVAL_SECS = 30
ALERT_SECS = 5
signal_get_ping = Signal()
signal_post_history = Signal(int, QDateTime)
def __init__(
self,
config_file: str
) -> None:
super().__init__()
# load config
try:
self.config = Config(config_file)
except Exception as e:
QMessageBox.critical(self, 'Config error', str(e))
QTimer.singleShot(0, self.close)
return
# load settings
self.settings = Settings()
# state
self.state_key: Optional[int] = None
# label widget
self.label_ping = ClickableLabel('Loading ...', self.post_history)
self.label_ping.setTextFormat(Qt.RichText)
self.label_ping.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
layout_ping = QGridLayout()
layout_ping.setContentsMargins(0, 0, 0, 0)
layout_ping.addWidget(self.label_ping)
self.widget_ping = QWidget()
self.widget_ping.setLayout(layout_ping)
self.addWidget(self.widget_ping)
# alert widget
self.label_alert = QLabel()
self.label_alert.setWordWrap(True)
self.label_alert.setAlignment(Qt.AlignCenter)
self.label_alert.setStyleSheet(f'background: #dddddd;')
self.addWidget(self.label_alert)
# context menu
self.action_report_done = QAction('Report done ...')
self.action_report_done.triggered.connect(self.report_done)
self.action_exit = QAction('Exit')
self.action_exit.triggered.connect(self.close)
self.action_frameless = QAction('Frameless window')
self.action_frameless.setCheckable(True)
self.action_frameless.triggered.connect(self.set_frameless_window)
self.action_homepage = QAction('Open homepage')
self.action_homepage.triggered.connect(self.open_homepage)
self.context_menu = QMenu()
self.context_menu.addAction(self.action_report_done)
self.context_menu.addAction(self.action_exit)
self.context_menu.addAction(self.action_frameless)
self.context_menu.addAction(self.action_homepage)
# threads
self.thread_communication = QThread()
self.thread_communication.start()
# workers
self.worker_communication = CommunicationWorker(
netloc=self.config.netloc,
base_path=self.config.base_path,
api_key=self.config.api_key,
guild=self.config.guild,
member=self.config.member)
self.worker_communication.moveToThread(self.thread_communication)
# signals
self.worker_communication.signal_get_ping_done.connect(self.get_ping_done)
self.worker_communication.signal_post_history_done.connect(self.post_history_done)
self.signal_get_ping.connect(self.worker_communication.get_ping)
self.signal_post_history.connect(self.worker_communication.post_history)
# get ping timer
QTimer.singleShot(0, self.get_ping)
self.timer_ping = QTimer()
self.timer_ping.timeout.connect(self.get_ping)
self.timer_ping.setTimerType(Qt.VeryCoarseTimer)
self.timer_ping.start(self.INTERVAL_SECS * 1000)
# switch label timer
self.timer_label = QTimer()
self.timer_label.timeout.connect(lambda: self.setCurrentWidget(self.widget_ping))
self.timer_label.setSingleShot(True)
self.timer_label.setTimerType(Qt.CoarseTimer)
# window attributes
size = self.settings.get('window', 'size', type_=QSize)
if size is not None:
self.resize(size)
pos = self.settings.get('window', 'pos', type_=QPoint)
if pos is not None:
self.move(pos)
frameless = self.settings.get('window', 'frameless', type_=bool)
if frameless is not None and frameless:
QTimer.singleShot(100, self.action_frameless.trigger)
self.setWindowFlag(Qt.WindowStaysOnTopHint, self.config.window_stays_on_top)
self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowTitle('Evelyn Reminder')
def closeEvent(
self,
event: QCloseEvent
) -> None:
# save settings
with suppress_and_log_exception():
self.settings.set('window', 'size', self.size())
self.settings.set('window', 'pos', self.pos())
self.settings.set('window', 'frameless', bool(self.windowFlags() & Qt.FramelessWindowHint))
# stop communication thread
with suppress_and_log_exception():
self.thread_communication.quit()
self.thread_communication.wait()
# done
super().closeEvent(event)
def contextMenuEvent(
self,
event: QContextMenuEvent
) -> None:
self.context_menu.exec_(event.globalPos())
@Slot()
def get_ping(self) -> None:
logging.info('Get ping ...')
self.signal_get_ping.emit()
@Slot(int, str, str)
def get_ping_done(
self,
key: int,
text: str,
color: str
) -> None:
logging.info('Get ping done')
if key == -1:
self.state_key = None
self.label_ping.setWordWrap(True)
else:
self.state_key = key
self.label_ping.setWordWrap(False)
self.label_ping.setText(text)
self.widget_ping.setStyleSheet(f'background : {color}; ')
@Slot()
def post_history(
self,
date_time: QDateTime = QDateTime()
) -> None:
# this method is called as Slot by ClickableLabel.mouseReleaseEvent() without arguments
# this method is called directly by EvelynDesktop.report_done() with a date_time
if self.state_key is None:
return
logging.info('Post history ...')
self.label_alert.setText('Sending ...')
self.label_alert.setStyleSheet(f'background: #dddddd;')
self.setCurrentWidget(self.label_alert)
self.signal_post_history.emit(self.state_key, date_time)
@Slot(str, bool)
def post_history_done(
self,
text: str,
error: bool
) -> None:
logging.info('Post history done')
self.label_alert.setText(text)
if error:
self.label_alert.setStyleSheet(f'background: #dd4b4b;')
self.timer_label.start(self.ALERT_SECS * 1000)
# trigger instant ping update to avoid outdated info
self.timer_ping.stop()
self.timer_ping.start(self.INTERVAL_SECS * 1000)
self.get_ping()
@Slot()
def report_done(self) -> None:
self.timer_ping.stop() # stop ping update while dialog is open
report_done_dialog = ReportDoneDialog(self)
response = report_done_dialog.exec()
if response != QDialog.Accepted:
self.timer_ping.start(self.INTERVAL_SECS * 1000)
self.get_ping()
return
date_time = report_done_dialog.get_date_time()
self.post_history(date_time)
@Slot(bool)
def set_frameless_window(
self,
value: bool
) -> None:
pos = self.pos()
self.setWindowFlag(Qt.FramelessWindowHint, value)
# workaround: window goes invisible otherwise
self.setVisible(True)
# workaround: window would move up otherwise
if value:
QTimer.singleShot(100, lambda: self.move(pos))
@Slot()
def open_homepage(self) -> None:
webbrowser.open('https://github.com/stefs/evelyn-reminder')
