11. 应用开发：Python 和 PySide6

# This Python file uses the following encoding: utf-8
import sys

from PySide6.QtWidgets import QApplication, QWidget, QLabel
from PySide6.QtGui import QFont

# Important:
# You need to run the following command to generate the ui_form.py file
#     pyside6-uic form.ui -o ui_form.py, or
#     pyside2-uic form.ui -o ui_form.py
from ui_form import Ui_Widget


class Widget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)

        self.hello_world()

    def hello_world(self):
        label = QLabel("Hello world!", self)
        label.move(100, 100)

        font = QFont("Arial", 16, QFont.Bold)
        label.setFont(font)

        label.setStyleSheet("color: green;")

        label.show()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

# -*- coding: utf-8 -*-

################################################################################
## Form generated from reading UI file 'form.ui'
##
## Created by: Qt User Interface Compiler version 6.8.2
##
## WARNING! All changes made in this file will be lost when recompiling UI file!
################################################################################

from PySide6.QtCore import (QCoreApplication, QDate, QDateTime, QLocale,
    QMetaObject, QObject, QPoint, QRect,
    QSize, QTime, QUrl, Qt)
from PySide6.QtGui import (QBrush, QColor, QConicalGradient, QCursor,
    QFont, QFontDatabase, QGradient, QIcon,
    QImage, QKeySequence, QLinearGradient, QPainter,
    QPalette, QPixmap, QRadialGradient, QTransform)
from PySide6.QtWidgets import (QApplication, QSizePolicy, QWidget)

class Ui_Widget(object):
    def setupUi(self, Widget):
        if not Widget.objectName():
            Widget.setObjectName(u"Widget")
        Widget.resize(800, 600)

        self.retranslateUi(Widget)

        QMetaObject.connectSlotsByName(Widget)
    # setupUi

    def retranslateUi(self, Widget):
        Widget.setWindowTitle(QCoreApplication.translate("Widget", u"Widget", None))
    # retranslateUi

{
    "files": [
        "widget.py",
        "form.ui"
    ]
}

import sys

from PySide6.QtWidgets import QApplication, QWidget, QPushButton, QLabel, QVBoxLayout
from PySide6.QtCore import Slot, Qt
from PySide6.QtGui import QFont

from ui_form import Ui_Widget


class Widget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)

        self.layout = QVBoxLayout()
        self.setLayout(self.layout)
        self.setWindowTitle("A Simple Button")

        self.signal_sayHello()

    def signal_sayHello(self):
        self.button = QPushButton("Click me")
        self.layout.addWidget(self.button)
        self.layout.setAlignment(self.button, Qt.AlignmentFlag.AlignCenter)

        self.label = QLabel()
        self.label.setStyleSheet("color: green;")
        self.layout.addWidget(self.label)
        self.layout.setAlignment(self.label, Qt.AlignmentFlag.AlignCenter)

        self.button.clicked.connect(self.slot_sayHello)

    @Slot()
    def slot_sayHello(self):
        self.label.clear()
        self.label.setText("Hi, guys!")

        font = QFont("Arial", 24, QFont.Bold)
        self.label.setFont(font)

        self.button.setText("You already clicked me")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

import sys

from PySide6.QtWidgets import QApplication, QWidget, QToolButton, QHBoxLayout, QLineEdit
from PySide6.QtCore import Slot

from ui_form import Ui_Widget


class Widget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)

        self.layout = QHBoxLayout()
        self.setLayout(self.layout)
        self.setWindowTitle("line_edit.clear")

        self.line_edit_clear()

    def line_edit_clear(self):
        line_edit = QLineEdit()
        self.layout.addWidget(line_edit)
        button = QToolButton()
        button.setText("Clear")
        self.layout.addWidget(button)

        button.clicked.connect(line_edit.clear)


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

import sys
import math

from PySide6.QtWidgets import (
    QApplication,
    QWidget,
    QLabel,
    QComboBox,
    QGridLayout,
    QPushButton,
)
from PySide6.QtCore import Slot, Signal, QObject, QUrl, QDate, Qt, QDate
from PySide6.QtGui import QIcon

from ui_form import Ui_Widget


class Signals(QObject):
    sg_message = Signal(str)
    sg_vals = Signal(int, str, int)
    sg_list = Signal(list)
    sg_dict = Signal(dict)
    sg_anything = Signal(object)
    sg_QUrl = Signal(QUrl)
    sg_date = Signal(QDate)


class Widget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)

        self.grid = QGridLayout()
        self.setLayout(self.grid)
        self.setWindowTitle("Signal Type")

        self.signals = Signals()
        self.signals_widgets()

    def signals_widgets(self):
        btn = QPushButton("Sending Signal")
        btn.clicked.connect(self.emit_custom_signal)
        self.grid.addWidget(btn, 0, 0, alignment=Qt.AlignmentFlag.AlignRight)

        self.combo_signals = QComboBox()
        self.signals_dict = {
            "message": [self.signals.sg_message, "message..."],
            "vals": [self.signals.sg_vals, (27, "message", 13)],
            "list": [self.signals.sg_list, [1, 2, 3, 4, 5]],
            "dict": [self.signals.sg_dict, {"a": 27, "b": 13}],
            "anything": [self.signals.sg_anything, math.pi],
            "QUrl": [self.signals.sg_QUrl, QUrl("https://coding-x.tech/")],
            "date": [self.signals.sg_date, QDate.currentDate()],
        }

        for key, val in self.signals_dict.items():
            self.combo_signals.addItem(QIcon(), key, val[0])

        self.grid.addWidget(
            self.combo_signals, 0, 1, alignment=Qt.AlignmentFlag.AlignLeft
        )

        self.label = QLabel("Waiting for signal...")
        self.grid.addWidget(
            self.label, 1, 0, 1, 2, alignment=Qt.AlignmentFlag.AlignCenter
        )

    @Slot()
    def emit_custom_signal(self):
        custom_signal = self.combo_signals.currentData()
        custom_signal_idx = self.combo_signals.currentText()

        custom_signal.connect(self.custom_slot)
        if custom_signal_idx == "vals":
            custom_signal.emit(*self.signals_dict[custom_signal_idx][1])
        else:
            custom_signal.emit(self.signals_dict[custom_signal_idx][1])

    @Slot()
    def custom_slot(self, *args):
        if isinstance(args[0], QDate):
            self.label.setText(args[0].toString())
        elif len(args) > 1:
            self.label.setText(str(args))
        else:
            self.label.setText(str(args[0]))


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

import sys

from PySide6.QtWidgets import (
    QApplication,
    QWidget,
    QLabel,
    QVBoxLayout,
    QPushButton,
)
from PySide6.QtCore import Slot, Signal, QObject

from ui_form import Ui_Widget


class Person(QObject):
    def __init__(self, name, age):
        super().__init__()
        self.name = name
        self.age = age

    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"


class Widget(QWidget):
    person_signal = Signal(Person)

    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)

        self.setWindowTitle("Signal-Custom Data Type")
        self.resize(300, 300)

        self.label = QLabel("Waiting for signal...", self)
        btn = QPushButton("Send Person Data", self)
        btn.clicked.connect(self.send_person_data)
        self.person_signal.connect(self.handle_person_data)

        layout = QVBoxLayout()
        layout.addWidget(btn)
        layout.addWidget(self.label)
        self.setLayout(layout)

    @Slot()
    def send_person_data(self):
        person = Person("John Doe", 18)
        self.person_signal.emit(person)

    @Slot()
    def handle_person_data(self, person):
        self.label.setText(f"Received: {person}")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

import sys

from PySide6.QtWidgets import (
    QWidget,
    QApplication,
    QPushButton,
    QLabel,
    QVBoxLayout,
)
from PySide6.QtCore import Slot, Signal, QObject

from ui_form import Ui_Widget


class Widget(QWidget):
    speak = Signal((int,), (str,))

    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)

        self.click_counter = 0

        self.setWindowTitle("Signal-Overloading")
        self.resize(300, 300)

        self.label = QLabel("Waiting for signal...", self)
        self.btn = QPushButton("say something", self)

        layout = QVBoxLayout()
        layout.addWidget(self.btn)
        layout.addWidget(self.label)
        self.setLayout(layout)

        self.btn.clicked.connect(self.emit_signal)
        self.speak[int].connect(self.say_something)
        self.speak[str].connect(self.say_something)

    @Slot()
    def emit_signal(self):
        self.click_counter += 1

        if self.click_counter == 1:
            self.speak.emit(100)
        elif self.click_counter == 2:
            self.speak[str].emit("Hello everybody!")
            self.click_counter = 0

    @Slot(int)
    @Slot(str)
    def say_something(self, arg):
        if isinstance(arg, int):
            self.label.setText(f"This is a number: {arg}")
            self.btn.setText("Clicked once.")
        elif isinstance(arg, str):
            self.label.setText(f"This is a string: {arg}")
            self.btn.setText("Clicked twice.")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

import sys

from PySide6.QtWidgets import (
    QWidget,
    QApplication,
    QPushButton,
    QLabel,
    QVBoxLayout,
)
from PySide6.QtCore import Slot, Signal, QObject

from ui_form import Ui_Widget


class Widget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)
        self.setWindowTitle("Intercepting signal")
        self.resize(300, 300)

        self.label = QLabel("Pass additional parameters...")
        btn_a = QPushButton("Btn-A")
        btn_b = QPushButton("Btn-B")

        layout = QVBoxLayout()
        layout.addWidget(btn_a)
        layout.addWidget(btn_b)
        layout.addWidget(self.label)
        self.setLayout(layout)

        btn_a.clicked.connect(self.intercepting_signal)
        btn_b.clicked.connect(lambda checked: self.button_clicked(checked, btn_b))

    @Slot()
    def intercepting_signal(self, checked):
        self.button_clicked(checked, "Btn-A")

    @Slot()
    def button_clicked(self, checked, info):
        if isinstance(info, QObject):
            self.label.setText(f"You just hit button: {info.text()}")
        elif isinstance(info, str):
            self.label.setText(f"You just hit button: {info}")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

import sys
import numpy as np

from PySide6.QtWidgets import (
    QWidget,
    QApplication,
    QPushButton,
    QLabel,
    QVBoxLayout,
)
from PySide6.QtCore import Slot, Signal, QObject

from ui_form import Ui_Widget


class Widget(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_Widget()
        self.ui.setupUi(self)
        self.setWindowTitle("Signal-Overloading")
        self.resize(300, 300)

        label = QLabel("Pass additional parameters...")
        btn = QPushButton("Button_transfer_data")

        layout = QVBoxLayout()
        layout.addWidget(btn)
        layout.addWidget(label)
        self.setLayout(layout)

        data = np.random.randint(0, 10, size=7)
        btn.clicked.connect(lambda: self.handle_signal(btn.text(), data, label))

    @Slot()
    def handle_signal(self, *args):
        button_text, info, label_widget=args
        label_widget.setText(f"button text: {button_text}\ndata: {info}")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = Widget()
    widget.show()
    sys.exit(app.exec())

# Copyright (C) 2013 Riverbank Computing Limited.
# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
import sys

from PySide6.QtWidgets import (
    QApplication,
    QMainWindow,
    QTextEdit,
    QMessageBox,
    QFileDialog,
)
from PySide6.QtGui import QIcon, QAction, QKeySequence, QPixmap
from PySide6.QtCore import (
    QSaveFile,
    QFile,
    QTextStream,
    Slot,
    QFileInfo,
    Qt,
    QSettings,
    QByteArray,
)

from ui_form import Ui_MainWindow

# pyside6-rcc application.qrc -o application_rc.py
import rc_application


class MainWindow(QMainWindow):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.resize(500, 500)

        self._cur_file = ""

        self._text_edit = QTextEdit()
        self.setCentralWidget(self._text_edit)

        self.create_actions()
        self.create_menus()
        self.create_tool_bars()
        self.create_status_bar()

        self.read_settings()

        self._text_edit.document().contentsChanged.connect(self.document_was_modified)

        self.set_current_file("")
        self.setUnifiedTitleAndToolBarOnMac(True)

    def create_actions(self):
        icon = QIcon(QPixmap(":resources/images/new.png"))
        self._new_act = QAction(
            icon,
            "&New",
            self,
            shortcut=QKeySequence.New,
            statusTip="Create a new file",
            triggered=self.new_file,
        )

        icon = QIcon(QPixmap(":resources/images/open.png"))
        self._open_act = QAction(
            icon,
            "&Open",
            self,
            shortcut=QKeySequence.Open,
            statusTip="Open an existing file",
            triggered=self.open,
        )

        icon = QIcon(QPixmap(":resources/images/save.png"))
        self._save_act = QAction(
            icon,
            "&Save",
            self,
            shortcut=QKeySequence.Save,
            statusTip="Save the document to disk",
            triggered=self.save,
        )

        self._save_as_act = QAction(
            "&Save &As...",
            self,
            shortcut=QKeySequence.SaveAs,
            statusTip="Save the document under a new name",
            triggered=self.save_as,
        )

        icon = QIcon.fromTheme(QIcon.ThemeIcon.ApplicationExit)
        self._exit_act = QAction(
            icon,
            "E&xit",
            self,
            shortcut="Ctrl+Q",
            statusTip="Exit the application",
            triggered=self.close,
        )

        icon = QIcon(QPixmap(":resources/images/cut.png"))
        self._cut_act = QAction(
            icon,
            "Cu&t",
            self,
            shortcut=QKeySequence.StandardKey.Cut,
            statusTip="Cut the current selection's contents to the clipboard",
            triggered=self._text_edit.cut,
        )

        icon = QIcon(QPixmap(":resources/images/copy.png"))
        self._copy_act = QAction(
            icon,
            "&Copy",
            self,
            shortcut=QKeySequence.StandardKey.Copy,
            statusTip="Copy the current selection's contents to the clipboard",
            triggered=self._text_edit.copy,
        )

        icon = QIcon(QPixmap(":resources/images/paste.png"))
        self._paste_act = QAction(
            icon,
            "&Paste",
            self,
            shortcut=QKeySequence.StandardKey.Copy,
            statusTip="Paste the clipboard's contents into the current selection",
            triggered=self._text_edit.paste,
        )

        icon = QIcon.fromTheme(QIcon.ThemeIcon.HelpAbout)
        self._about_act = QAction(
            icon,
            "&About",
            self,
            statusTip="Show the application's About box",
            triggered=self.about,
        )

        self._about_qt_act = QAction(
            "&About &Qt",
            self,
            statusTip="Show the Qt library's About box",
            triggered=qApp.aboutQt,
        )

    def create_menus(self):
        self._file_menu = self.menuBar().addMenu("&File")
        self._file_menu.addAction(self._new_act)
        self._file_menu.addAction(self._open_act)
        self._file_menu.addAction(self._save_act)
        self._file_menu.addAction(self._save_as_act)
        self._file_menu.addSeparator()
        self._file_menu.addAction(self._exit_act)

        self._edit_menu = self.menuBar().addMenu("&Edit")
        self._edit_menu.addAction(self._cut_act)
        self._edit_menu.addAction(self._copy_act)
        self._edit_menu.addAction(self._paste_act)

        self.menuBar().addSeparator()

        self._help_menu = self.menuBar().addMenu("&Help")
        self._help_menu.addAction(self._about_act)
        self._help_menu.addAction(self._about_qt_act)

    def create_tool_bars(self):
        self._file_tool_bar = self.addToolBar("File")
        self._file_tool_bar.addAction(self._new_act)
        self._file_tool_bar.addAction(self._open_act)
        self._file_tool_bar.addAction(self._save_act)

        self._edit_tool_bar = self.addToolBar("Edit")
        self._edit_tool_bar.addAction(self._cut_act)
        self._edit_tool_bar.addAction(self._copy_act)
        self._edit_tool_bar.addAction(self._paste_act)

    def create_status_bar(self):
        self.statusBar().showMessage("Ready")

    def closeEvent(self, event):
        if self.maybe_save():
            self.write_settings()
            event.accept()
        else:
            event.ignore()

    def read_settings(self):
        settings = QSettings("QtProject", "Application Example")
        geometry = settings.value("geometry", QByteArray())
        if geometry.size():
            self.restoreGeometry(geometry)

    def write_settings(self):
        settings = QSettings("QtProject", "Application Example")
        settings.setValue("geometry", self.saveGeometry())

    @Slot()
    def new_file(self):
        if self.maybe_save():
            self._text_edit.clear()
            self.set_current_file("")

    @Slot()
    def save(self):
        if self._cur_file:
            return self.save_file(self._cur_file)
        return self.save_as()

    @Slot()
    def save_as(self):
        fileName, filtr = QFileDialog.getSaveFileName(self)
        if fileName:
            return self.save_file(fileName)
        return False

    @Slot()
    def document_was_modified(self):
        self.setWindowModified(self._text_edit.document().isModified())

    @Slot()
    def open(self):
        if self.maybe_save():
            fileName, filtr = QFileDialog.getOpenFileName(self)
            if fileName:
                self.load_file(fileName)

    @Slot()
    def about(self):
        QMessageBox.about(
            self,
            "About Application",
            "The <b>Application</b> example demonstrates how to write modern GUI application using Qt, with a menu bar, toolbars, and a status bar.",
        )

    def maybe_save(self):
        if self._text_edit.document().isModified():
            ret = QMessageBox.warning(
                self,
                "Application",
                "The document has been modified. \nDo you want to save your changes?",
                QMessageBox.StandardButton.Save
                | QMessageBox.StandardButton.Discard
                | QMessageBox.StandardButton.Cancel,
            )
            if ret == QMessageBox.StandardButton.Save:
                return self.save()
            elif ret == QMessageBox.StandardButton.Cancel:
                return False
        return True

    def load_file(self, fileName):
        file = QFile(fileName)
        if not file.open(QFile.OpenModeFlag.ReadOnly | QFile.OpenModeFlag.Text):
            reason = file.errorString()
            QMessageBox.warning(
                self, "Application", f"Cannot read file {fileName}:\n{reason}."
            )
            return

        inf = QTextStream(file)
        with QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor):
            self._text_edit.setPlainText(inf.readAll())

        self.set_current_file(fileName)
        self.statusBar().showMessage("File loaded", 2000)

    def save_file(self, fileName):
        error = None
        with QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor):
            file = QSaveFile(fileName)
            if file.open(QFile.OpenModeFlag.WriteOnly | QFile.OpenModeFlag.Text):
                outf = QTextStream(file)
                outf << self._text_edit.toPlainText()
                if not file.commit():
                    reason = file.errorString()
                    error = f"Cannot write file {fileName}:\n{reason}."
            else:
                reason = file.errorString()
                error = f"Cannot open file {fileName}:\n{reason}."
        if error:
            QMessageBox.warning(self, "Application", error)
            return False

    def set_current_file(self, fileName):
        self._cur_file = fileName
        self._text_edit.document().setModified(False)
        self.setWindowModified(False)

        if self._cur_file:
            shown_name = self.stripped_name(self._cur_file)
        else:
            shown_name = "untitled.txt"

        self.setWindowTitle(f"{shown_name}[*] - Application")

    def stripped_name(self, fullFileName):
        return QFileInfo(fullFileName).fileName()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    widget = MainWindow()
    widget.show()
    sys.exit(app.exec())

import QtQuick
import QtQuick.Window
import QtQuick.Controls

ApplicationWindow {
    width: 200
    height: 200
    visible: true
    title: qsTr("Hello World")

    Label{
        id: label
        text: "Click the button!"
        anchors.centerIn: parent
    }

    Button{
        text: "Click Me"
        anchors.bottom: parent.bottom
        anchors.horizontalCenter: parent.horizontalCenter
        onClicked:{
            label.text="Hello World!"
        }
    }
}

# This Python file uses the following encoding: utf-8
import sys
from pathlib import Path

from PySide6.QtGui import QGuiApplication
from PySide6.QtQml import QQmlApplicationEngine


if __name__ == "__main__":
    app = QGuiApplication(sys.argv)
    engine = QQmlApplicationEngine()
    qml_file = Path(__file__).resolve().parent / "main.qml"
    engine.load(qml_file)
    if not engine.rootObjects():
        sys.exit(-1)
    sys.exit(app.exec())

{
    "files": [
        "main.py",
        "main.qml"
    ]
}

import QtQuick
import QtQuick.Window

Window {
    width: 300
    height: 300
    visible: true
    title: qsTr("Hierarchy")

    Rectangle{
        width: 280
        height: 50
        color: "red"
        anchors.centerIn: parent

        Text {
            anchors.centerIn: parent
            font.family: "Helvetica"
            font.pointSize: 24
            text: qsTr("Hello QML.")
        }
    }

}

# This Python file uses the following encoding: utf-8
import sys
from pathlib import Path

from PySide6.QtGui import QGuiApplication
from PySide6.QtQml import QQmlApplicationEngine


if __name__ == "__main__":
    app = QGuiApplication(sys.argv)
    engine = QQmlApplicationEngine()
    qml_file = Path(__file__).resolve().parent / "main.qml"
    engine.load(qml_file)
    if not engine.rootObjects():
        sys.exit(-1)
    sys.exit(app.exec())

import QtQuick
import QtQuick.Controls
import QtQuick.Layouts
import QtQuick.Controls.Material

ApplicationWindow {
    width: 420
    height: 320
    visible: true
    title: qsTr("QtQuick Example with Menubar, ToolBar, and Statusbar")

    Material.theme: Material.Light
    Material.primary: Material.Green
    Material.accent: Material.Red

    ActionGroup{
        id: actionGroup
        exclusive: false

        Action{
            id: actionNew
            text: "New"
            shortcut: "Ctrl+N"
            onTriggered: {
                label.text="New file action triggered"
            }
        }
        Action{
            id: actionOpen
            text: "&Open"
            shortcut: "Ctrl+O"
            onTriggered: {
                label.text="Open file action triggered"
            }
        }
        Action{
            id: actionExit
            text: "&Exit"
            shortcut: "Ctrl+Q"
            onTriggered: {
                Qt.quit()
            }
        }
    }

    menuBar: MenuBar{
        Menu{
            title: qsTr("&File")
            MenuItem {
                action: actionNew
                onHoveredChanged: if(hovered) {statusBar.text="New file" } else {statusBar.text="Ready"}

            }
            MenuItem {
                action: actionOpen
                onHoveredChanged: if(hovered) {statusBar.text="Open file" } else {statusBar.text="Ready"}
            }
            MenuItem {
                action: actionExit
                onHoveredChanged: if(hovered) {statusBar.text="Exit file" } else {statusBar.text="Ready"}
            }
        }
        Menu{
            title: qsTr("&Help")
            MenuItem{
                text: qsTr("&About...")
                onTriggered: aboutDialog.open()
            }
        }
    }

    header: ToolBar{
        RowLayout{
            ToolButton{text: qsTr("New");icon.name: "document-new";action: actionNew}
            ToolButton{
                text: qsTr("Open")
                icon.name: "document-open"
                action: actionOpen
            }
            ToolButton{text: qsTr("Exit");icon.name: "❌";action: actionExit}
            ToolButton{text: qsTr("About");icon.name: "?"; onClicked: aboutDialog.open() }
        }
    }

    footer: ToolBar{
        RowLayout{
            anchors.fill: parent
            Label{
                id: statusBar
                text: "Ready"
            }
        }
    }

    ColumnLayout{
        anchors.centerIn: parent
        spacing: 10

        Label{
            id: label
            font.pointSize: 24
            text: "..."
            Layout.alignment: Qt.AlignCenter
        }

        Button{
            text: qsTr("Say Hi!")
            anchors.horizontalCenter: parent.horizontalCenter
            onClicked:{
                label.text="Hi, Guys!"
            }

        }
    }

    Item{
        id: dialogGroup

        Dialog{
            id: aboutDialog
            title: qsTr("About")

            contentItem: Rectangle{
                color: "transparent"
                implicitWidth: 180
                implicitHeight: 100
                Text {
                    text: "While Qt Quick provides basic graphical elements,\
Qt Quick Controls provides ready-made QML types for use within an application."
                    color:"green"
                    wrapMode: Text.WordWrap
                    width: 200
                    anchors.centerIn: parent
                }
            }
            standardButtons: Dialog.Ok
            parent: Overlay.overlay
            anchors.centerIn: parent
       }
    }

}

# This Python file uses the following encoding: utf-8
import sys
from pathlib import Path

from PySide6.QtGui import QGuiApplication
from PySide6.QtQml import QQmlApplicationEngine
from PySide6.QtQuickControls2 import QQuickStyle


if __name__ == "__main__":
    app = QGuiApplication(sys.argv)
    QQuickStyle.setStyle("Material")

    engine = QQmlApplicationEngine()
    qml_file = Path(__file__).resolve().parent / "main.qml"
    engine.load(qml_file)
    if not engine.rootObjects():
        sys.exit(-1)
    sys.exit(app.exec())

import QtQuick
import QtQuick.Controls
import QtQuick.Layouts
import QtQuick.Controls.Material

ApplicationWindow {
    width: 500
    height: 500
    visible: true
    title: qsTr("Handling User Input")

    Text{
        id: hui
        text: "Hanlding User Input"
        parent:Overlay.overlay
        anchors.centerIn: parent
        font.pointSize: 18
        wrapMode: Text.WordWrap
        width: 400
    }

    Rectangle{
        width:400
        height:350
        color:"lightblue"
        anchors.centerIn: parent
        focus: true

        TapHandler{
            acceptedButtons: Qt.RightButton
            onTapped: {parent.color="blue"; hui.text="[Right btn]Tap event triggered!"}
            onDoubleTapped: {parent.color="red"; hui.text="[Right btn]Double tap event triggered!"}
            onLongPressed: {parent.color="green"; hui.text="[Right btn]Long-press event triggered!"}
        }

        Keys.onPressed: (event)=>{
                            hui.text="Key: "+event.key
                            if (event.key===Qt.Key_Enter || event.key===Qt.Key_Return){
                                hui.text="The enter key pressed!"
                            }
                        }
    }

    MouseArea{
        anchors.fill: parent
        onClicked: (mouse)=>{hui.text=qsTr('[Left btn]Mouse click position:\nx= %1 y=%2').arg( mouse.x).arg(mouse.y)}
        //onPressed: hui.text="Mouse down"
        //onReleased: hui.text="Mouse release"
    }

    TextField{
        width: 400
        placeholderText: "Please enter content..."
        anchors.bottom: parent.bottom
        anchors.horizontalCenter: parent.horizontalCenter
        onTextChanged: hui.text="<b>Current input:</b><br>"+text
    }
}