def __init__(self, controller):
"""Set up the main window and initialise widgets.
Args:
controller: A route controller.
"""
super().__init__()
self._ct = controller
self._widgets = {}
self._ui = Ui_MainWindow()
self._ui.setupUi(self)
self._ui.about_action.triggered.connect(self.aboutInfo)
self._ui.file_load_action.triggered.connect(self.fileLoadPrompt)
self._ui.exit_btn.clicked.connect(self.close)
self._ui.download_btn.clicked.connect(controller.downloadAction)
self._ui.download_action.triggered.connect(controller.downloadAction)
self._ct.register(self.startRouteSelect, "LOADED")
self._ct.register(self.displayError, "ERROR")
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# initialize ui
self.initUI()
# no frame window
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
class MainWindow(QtGui.QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# initialize ui
self.initUI()
# no frame window
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
def initUI(self):
self.ui.lineEdit.textEdited[str].connect(self.updateLabelText)
self.ui.pushButton.clicked.connect(self.buttonClick)
#resize window when no frame window
self.ui.verticalLayoutRight.addWidget(QtGui.QSizeGrip(self), 0, QtCore.Qt.AlignBottom | QtCore.Qt.AlignRight)
def buttonClick(self):
QtGui.QMessageBox.about(self, 'title', 'content')
def updateLabelText(self, text):
self.ui.label.setText(text)
#add for window movable
def mousePressEvent(self, event):
""" override mouse press event """
self._postion = event.globalPos() - self.pos()
def mouseMoveEvent(self, event):
""" override mouse move event """
self.move(event.globalPos() - self._postion)
def closeEvent(self, event):
""" override close event """
event.accept()
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.scene_org = QGraphicsScene()
self.scene_reduced = QGraphicsScene()
self.scene_template = QGraphicsScene()
self.ui.graphicsViewOriginal.setScene(self.scene_org)
self.controller = None
self.computation_started = False
# slots
self.resized.connect(self.resize_image)
self.ui.tabWidget.currentChanged.connect(self.resize_image)
self.ui.toolButtonOpenPhoto.clicked.connect(self.__select_image)
self.ui.pushButtonStart.clicked.connect(self.__start_computation)
self.ui.pushButtonExport.clicked.connect(self.__export)
self.installEventFilter(self)
class MainWindow(Qw.QMainWindow):
"""Primary view class for TrekApp.
MainWindow instantiates widgets for each 'screen' in the app.
Screens are drawn inside the main window.
"""
def __init__(self, controller):
"""Set up the main window and initialise widgets.
Args:
controller: A route controller.
"""
super().__init__()
self._ct = controller
self._widgets = {}
self._ui = Ui_MainWindow()
self._ui.setupUi(self)
self._ui.about_action.triggered.connect(self.aboutInfo)
self._ui.file_load_action.triggered.connect(self.fileLoadPrompt)
self._ui.exit_btn.clicked.connect(self.close)
self._ui.download_btn.clicked.connect(controller.downloadAction)
self._ui.download_action.triggered.connect(controller.downloadAction)
self._ct.register(self.startRouteSelect, "LOADED")
self._ct.register(self.displayError, "ERROR")
@pyqtSlot()
def fileLoadPrompt(self):
"""Ask user to select a file, then pass the filename to controller."""
filename, _ = Qw.QFileDialog.getOpenFileName(self, 'Route file', '/')
if filename:
self._ct.fileLoadAction(filename)
@pyqtSlot()
def aboutInfo(self):
"""Display a message with information about the program."""
msg = "Hello, and welcome to my assignment!\n"\
"For more information, please see readme.md in the main program "\
"directory."
Qw.QMessageBox.information(self, "About", msg)
def startRouteSelect(self, route_collection):
"""Create and open the route selection screen.
If route screen existed previously, it is destroyed.
"""
stack = self._ui.screen_stack
if "RouteSelectScreen" in self._widgets:
stack.removeWidget(self._widgets["RouteSelectScreen"])
screen = RouteSelectScreen(self, self._ct)
self._widgets["RouteSelectScreen"] = screen
stack.addWidget(screen)
screen.routeSelected.connect(self.startTracking)
stack.setCurrentWidget(self._widgets["RouteSelectScreen"])
@pyqtSlot()
def displayRouteSelect(self):
"""Called when a user finishes tracking a route."""
self._ui.screen_stack.setCurrentWidget(
self._widgets["RouteSelectScreen"])
@pyqtSlot(str)
def startTracking(self, route_name):
"""Create and open a tracking screen for the given route.
If previously opened, destroy the original screen."""
controller = self._ct.startNavigation(route_name)
if not controller:
self.displayError(
"Something went wrong while accessing the route :(")
else:
if "TrackingScreen" in self._widgets:
self._ui.screen_stack.removeWidget(
self._widgets["TrackingScreen"])
screen = TrackingScreen(self, controller)
screen.exitTracking.connect(self.displayRouteSelect)
self._widgets["TrackingScreen"] = screen
self._ui.screen_stack.addWidget(screen)
self._ui.screen_stack.setCurrentWidget(screen)
def closeEvent(self, event):
"""Handle a request to close the app with a confirmation prompt."""
reply = Qw.QMessageBox.question(self, "Exit", "Really exit?",
Qw.QMessageBox.Yes | Qw.QMessageBox.No,
Qw.QMessageBox.No)
if reply == Qw.QMessageBox.Yes:
Qw.QApplication.instance().quit()
else:
event.ignore()
@pyqtSlot(str)
def displayError(self, message):
"""Print an error message to the user in a popup message box.
Args:
message: Full content of the error message to display.
"""
msg = Qw.QMessageBox()
msg.setText(message)
msg.exec_()
class MainWindow(QMainWindow, Observer):
resized = Signal()
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.scene_org = QGraphicsScene()
self.scene_reduced = QGraphicsScene()
self.scene_template = QGraphicsScene()
self.ui.graphicsViewOriginal.setScene(self.scene_org)
self.controller = None
self.computation_started = False
# slots
self.resized.connect(self.resize_image)
self.ui.tabWidget.currentChanged.connect(self.resize_image)
self.ui.toolButtonOpenPhoto.clicked.connect(self.__select_image)
self.ui.pushButtonStart.clicked.connect(self.__start_computation)
self.ui.pushButtonExport.clicked.connect(self.__export)
self.installEventFilter(self)
def eventFilter(self, widget, event):
if event.type() == QEvent.KeyPress:
key = event.key()
if key == Qt.Key_Return and not self.computation_started:
self.__start_computation()
elif key == Qt.Key_Enter and not self.computation_started:
self.__start_computation()
return True
return QWidget.eventFilter(self, widget, event)
def set_controller(self, controller):
self.controller = controller
def __select_image(self):
file_dialog = QFileDialog()
MainWindow.__set_file_dialog_options(
file_dialog,
get_config().getboolean('UI', 'NO_NATIVE_DIALOG'))
path = file_dialog.getOpenFileName(
self, 'Open File', " ../../", 'Images (*.png *.svg *.jpg *.jpeg)',
'')[0]
if path:
self.controller.open_image(path)
self.ui.tabWidget.setCurrentIndex(0)
self.resize_image()
@staticmethod
def __set_file_dialog_options(file_dialog, is_not_native_dialog):
file_dialog.setOption(QFileDialog.DontUseNativeDialog,
is_not_native_dialog)
def __start_computation(self):
if self.controller:
self.__disable_ui(True)
self.__set_computation_text()
worker = ComputeCanvasWorker(
self.ui.spinBoxNumberOfColors.value(),
self.ui.comboBoxPrintSize.currentText(),
self.ui.spinBoxMinSurfaceSize.value(),
self.ui.checkBox.isChecked(), self.controller) # no parent!
self.controller.register_observer(worker)
self.thread = QThread()
worker.moveToThread(self.thread)
worker.finished.connect(self.thread.quit)
self.thread.started.connect(worker.run)
self.thread.start()
def __export(self):
file_name = self.open_save_file_dialog(
) if self.controller.canvas else ""
self.controller.export(self.ui.comboBoxPrintSize.currentText(),
file_name=file_name)
def display_image(self, img_data):
self.__clear_scenes()
self.__add_image_to_scene(self.scene_org, img_data[0])
if img_data[1]:
self.__add_image_to_scene(self.scene_reduced, img_data[1])
self.__add_image_to_scene(self.scene_template, img_data[2])
self.ui.tabWidget.setCurrentIndex(1)
def __set_computation_text(self):
self.scene_org = QGraphicsScene()
self.scene_org.addText("It'll take a moment.")
self.ui.graphicsViewOriginal.setScene(self.scene_org)
self.ui.tabWidget.setCurrentIndex(0)
self.computation_started = True
self.resize_image()
def __clear_scenes(self):
self.scene_org = QGraphicsScene()
self.scene_reduced = QGraphicsScene()
self.scene_template = QGraphicsScene()
self.ui.graphicsViewOriginal.setScene(self.scene_org)
self.ui.graphicsViewReducedColors.setScene(self.scene_reduced)
self.ui.graphicsViewTemplate.setScene(self.scene_template)
def __disable_ui(self, boolean):
self.ui.pushButtonStart.setDisabled(boolean)
self.ui.pushButtonExport.setDisabled(boolean)
self.ui.toolButtonOpenPhoto.setDisabled(boolean)
self.ui.spinBoxNumberOfColors.setDisabled(boolean)
self.ui.spinBoxMinSurfaceSize.setDisabled(boolean)
self.ui.comboBoxPrintSize.setDisabled(boolean)
self.ui.checkBox.setDisabled(boolean)
self.ui.tabWidget.setDisabled(boolean)
def __add_image_to_scene(self, scene, image):
pixmap = self.__pil_to_pixmap(image)
scene.addPixmap(pixmap)
@staticmethod
def __pil_to_pixmap(img):
if img.mode == "RGB":
pass
elif img.mode == "L":
img = img.convert("RGBA")
data = img.convert("RGBA").tobytes("raw", "BGRA")
qim = QImage(data, img.size[0], img.size[1], QImage.Format_ARGB32)
pixmap = QPixmap.fromImage(qim)
return pixmap
def resizeEvent(self, event):
self.resized.emit()
return super(MainWindow, self).resizeEvent(event)
def resize_image(self):
if self.controller:
if self.computation_started:
self.ui.graphicsViewOriginal.fitInView(
QRectF(0, 0, self.scene_org.width(),
self.scene_org.height()), Qt.KeepAspectRatio)
else:
self.ui.graphicsViewOriginal.fitInView(
QRectF(0, 0,
self.controller.get_image_size()[0],
self.controller.get_image_size()[1]),
Qt.KeepAspectRatio)
self.ui.graphicsViewReducedColors.fitInView(
QRectF(0, 0,
self.controller.get_image_size()[0],
self.controller.get_image_size()[1]),
Qt.KeepAspectRatio)
self.ui.graphicsViewTemplate.fitInView(
QRectF(0, 0,
self.controller.get_image_size()[0],
self.controller.get_image_size()[1]),
Qt.KeepAspectRatio)
def open_save_file_dialog(self):
file_dialog = QFileDialog()
file_name = file_dialog.getSaveFileName(self, 'Save as PDF', " ../../",
'PDF (*.pdf)', '')[0]
return file_name
@staticmethod
def show_message(text):
msgBox = QMessageBox()
msgBox.setText(text)
msgBox.exec_()
def notify(self, update_data):
self.computation_started = False
self.__disable_ui(False)
if isinstance(update_data, str):
self.show_message(update_data)
else:
self.display_image(update_data)
