23. 对话框控件

一、对话框应用

  对话框窗口是一个用来完成简单任务或者和用户进行临时交互的顶层窗口，通常用于输入信息、确认信息或者提示信息。QDialog 类是所有对话框窗口类的基类。

  按照运行时是否可以和其他窗口进行交互操作，对话框分为模式（或模态）对话框和非模式对话框。对于带有模式的对话框，只有在关闭该对话框的情况下才可以对其他窗口进行操作；而对于非模式对话框，在没有关闭对话框的情况下，既可以对该对话框进行操作，也可以对其他窗口进行操作。

  对话框在操作系统的管理器中没有独立的任务栏，而是共享父窗口的任务栏，无论对话框是否处于活跃状态，对话框都将位于父窗口之上，除非关闭或隐藏对话框。

  我们可以在终端中使用 pip 安装 pyside6 模块。

pip install pyside6

  QDialog 是从 QWidget 类继承而来的，用 QDialog 类创建一般对话框实例的方法如下：

QDialog(parent:QWidget=None, f:Qt.WindowFlags=Default(Qt.WindowFlags))

  其中 parent 是 QDialog 对话框的 父窗口，Qt.WindowFlags 的取值参考 QWidget 窗口部分。通常将 QDialog 对话框作为顶层窗口使用，在主程序界面中进行调用。

  QDialog 类的常用方法如下：

open() -> None                              # 以模式方法显示对话框
exec() -> int                               # 以模式方法显示对话框，并返回对话框的值
accept() -> None                            # 隐藏对话框，并将返回值设置成QDialog.Accepted，同时发送accepted()和finished(int)信号
done(arg__1:int) -> None                    # 隐藏对话框，并将返回值设置成arg__1，同时发送finished(int)信号
reject() -> None                            # 隐藏对话框，并将返回值设置成QDialog.Rejected，同时发送rejected()和finished(int)信号
setModal(modal:bool) -> None                # 设置对话框为模式对话框
setResult(result:int) -> None               # 设置对话框的返回值
result() -> int                             # 返回对话框的返回值
setSizeGripEnabled(arg__1:bool) -> None     # 设置对话框的右下角是否有三角形
isSizeGripEnabled() -> bool                 # 返回对话框的右下角是否有三角形
setVisible(visible:bool) -> None            # 设置对话框是否可见

  对话框的模式特性可以用 setModal(bool) 或 setWindowModality(Qt.WindowModality) 方法设置，其中枚举参数 Qt.WindowModality 可以取值如下：

Qt.WindowModality.NonModal           # 非模式，可以和程序的其他窗口进行交互操作
Qt.WindowModality.WindowModal        # 窗口模式，在未关闭当前对话框时，将阻止该窗口与父窗口的交互操作
Qt.WindowModality.ApplicationModal   # 应用程序模式，在未关闭当前对话框时，将阻止与任何其他窗口的交互操作

  显示对话框的方法有 show()、open() 和 exec() 三种。如果对话框已经有模式特性，则用 show() 方法显示的对话框具有模式特性，如果对话框没有模式特性，则用 show() 方法显示的对话框没有模式特性；无论对话框是否有模式特性，用 open() 或 exec() 方法显示的对话框都是模式对话框，其中用 open() 方法显示的对话框默认是窗口模式，用 exec() 方法显示的对话框默认是应用程序模式。当程序执行到 show() 或 open() 方法时，显示对话框后，会继续执行后续的代码，而用 exec() 方法显示对话框时，需关闭对话框后才执行 exec() 语句的后续代码。show()、open()和exec()三种显示对话框的方法不会改变对话框的模式属性的值。

  这里所说的对话框的返回值不是在对话框的控件中输入的值，而是指对话框被隐藏或删除时返回的一个整数，用这个整数表示用户对对话框的操作。

  通常对话框上有 “确定” 按钮（或 OK 按钮）、“应用” 按钮（或 Apply 按钮）和 “取消” 按钮（或 Cancel 按钮）。单击 “确定” 按钮表示接受和使用对话框中输入的值，单击 “取消” 按钮表示放弃或不使用对话框中输入的值。为了区分客户选择了哪个按钮，可以为对话框设个返回值，例如用 1 表示单击 “确定” 按钮，用 0 表示单击 “放弃” 按钮，用 2 表示单击 “应用” 按钮。

  QDialog 定义了两个枚举类型常量 QDialog.Accepted 和 QDialog.Rejected，这两个常量的值分别是 1 和 0。可以用 setResult(result:int) 方法为对话框设置一个返回值，用 result() 方法获取对话框的返回值，例如单击 “确认” 按钮时，隐藏对话框，并把对话框的返回值设置成 setResult(QDialog.Accepted)；单击 “取消” 按钮时，隐藏对话框，并把对话框的返回值设置成 setResult(QDialog.Rejected)。

  QDialog的 accept() 方法可以隐藏对话框，并把对话框的返回值设置成 QDialog.Accepted；reject() 方法会隐藏对话框，并把对话框的返回值设置成 QDialog.Rejected；用 done(arg_1) 方法会隐藏对话框，并把对话框的返回值设置成 arg_1。其实 accept() 方法调用的就是 done(QDialog.Accepted) 方法，reject() 方法调用的就是 done(QDialog.Rejected) 方法。如果对话框是用 exec() 方法显示的，则 exec() 方法会返回对话框的值，而 show() 和 open() 方法不会返回对话框的值。

  QDialog 类的常用信号如下：

accepted()                  # 执行accept()和done(int)方法时发射信号
finished(result:int)        # 执行accept()、reject()和done(int)方法时发射信号
rejected()                  # 执行reject()和done(int)方法时发射信号

import sysfrom PySide6.QtWidgets import QApplication, QMainWindow
from PySide6.QtWidgets import QDialog
from PySide6.QtWidgets import QLineEdit, QPushButton
from PySide6.QtWidgets import QVBoxLayout, QHBoxLayout, QFormLayoutclass MyWidget(QMainWindow):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建对话框控件dialog = QDialog(self)# 3.创建对话框的整体布局layout_V = QVBoxLayout(dialog)# 4.创建表单布局，并添加控件form = QFormLayout()layout_V.addLayout(form)line_name = QLineEdit()line_name.setPlaceholderText("请输入姓名")form.addRow("姓名:", line_name)line_gender = QLineEdit()line_gender.setPlaceholderText("请输入性别")form.addRow("性别:", line_gender)line_age = QLineEdit()line_age.setPlaceholderText("请输入年龄")form.addRow("年龄:", line_age)# 5.创建水平布局，添加按钮控件layout_H = QHBoxLayout()layout_V.addLayout(layout_H)button_apply = QPushButton("应用")layout_H.addWidget(button_apply)button_ok = QPushButton("确定")layout_H.addWidget(button_ok)button_cancel = QPushButton("取消")layout_H.addWidget(button_cancel)# 6.打开对话框dialog.open()if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

二、信息对话框

  在 PySide6 中，使用 QMessageBox 类表示对话框，PySide 中内置了 5 种不同类型的对话框，分别是消息对话框、问答对话框、警告对话框、错误对话框和关于对话框。它们的主要区别在于弹出的对话框的图标不同。

  信息对话框 QMessageBox 用于向用户提供一些信息，或者询问用户如何进行下一步操作。信息对话框由 文本（text、informativeText、detailedText）、图标 和 按钮 3 部分构成，因此在建立信息对话框时，主要设置这 3 部分的参数。

  用 QMessageBox 类创建信息对话框的方法如下：

QMessageBox(parent:QWidget=None)
QMessageBox(icon:QMessageBox.Icon, title:str, buttons:QMessageBox.StandardButtons=QMessageBox.StandardButton.NoButton, parent:QWidget=None, flags:Qt.WindowFlags=Qt.Dialog | Qt.MSWindowsFixedSizeDialogHint)

  其中 icon 是 对话框中的图标，title 是 对话框的标题，text 是 对话框中显示的文本，buttons 设置 对话框中的按钮，；flags 设置 窗口的类型，使用默认值即可。

  用 QMessageBox 类常用方法如下：

# 实例方法
setText(text:str) -> None                                                   # 设置信息对话框的文本
text() -> str                                                               # 获取信息对话框的文本
setInformativeText(text:str) -> None                                        # 设置对话框的信息文本
informativeText() -> str                                                    # 获取对话框的信息文本
setDetailedText(text:str) -> None                                           # 设置对话框的详细文本
detailedText() -> str                                                       # 获取对话框的详细文本
setTextFormat(format:Qt.TextFormat) -> None                                 # 设置文本格式setIcon(icon:QMessageBox.Icon) -> None                                      # 设置对话框的标准图标
setIconPixmap(pixmap:QPixmap) -> None                                       # 设置对话框的自定义图标
icon() -> QIcon                                                             # 获取对话框的标准图标
iconPixmap() -> QPixmap                                                     # 获取对话框的自定义图标setCheckBox(cb:QCheckBox) -> None                                           # 信息对话框中添加QCheckBox控件
checkBox() -> QCheckBox                                                     # 获取信息对话框中的QCheckBox控件addButton(button:QMessBox.StandardButton) -> QPushButton                    # 对话框中添加标准按钮
addButton(text:str, role:QMessageBox.ButtonRole) -> QPushButton             # 对话框中添加新建按钮，并返回新建按钮
addButton(button:QAbstractButton, role:QMessageBox.ButtonRole) -> None      # 对话框中添加按钮，并设置按钮的作用
button(which:QMessageBox.StandardButton) -> QAbstractButton                 # 获取对话框中的标准按钮
buttons() -> List[QAbstractButton]                                          # 获取对话框中按钮列表
buttonText(button:int) -> str                                               # 获取按钮上的文本
buttonRole(button:QAbstractButton) -> QMessageBox.ButtonRole                # 获取按钮的角色
removeButton(button:QAbstractButton) -> None                                # 删除对话框中的按钮
setDefaultButton(button:QPushButton) -> None                                # 设置默认按钮
setDefaultButton(button:QMessageBox.StandardButton) -> None                 # 将某一标准按钮设置为默认按钮
defaultButton() -> QPushButton                                              # 获取默认按钮setEscapeButton(button:QAbstractButton) -> None                             # 设置Esc键关闭对话框的按钮
setEscapeButton(button:QMessageBox.StandardButton) -> None                  # 将某一标准按钮设置为Esc键关闭对话框的按钮
escapeButton() -> QAbstractButton                                           # 获取Esc键关闭对话框的按钮clickedButton() -> QAbstractButton                                          # 获取用户点击的按钮# 静态方法# 用于快速构建信息对话框，除about()函数外，其它函数返回值是被单击的按钮或按钮的角色识别号# 关于对话框
about(parent:QWidget, title:str, text:str) -> None# 消息对话框
information(parent:QWidget, title:str, text:str, buttons:QMessageBox.StandardButton=QMessageBox.StandardButton.Ok, defaultButton:QMessageBox.StandardButton=QMessageBox.StandardButton.NoButton) -> QMessageBox.StandardButton# 问答对话框
question(parent:QWidget, title:str, text:str, buttons:QMessageBox.StandardButton=QMessageBox.StandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No), defaultButton:QMessageBox.StandardButton=QMessageBox.StandardButton.NoButton) -> QMessageBox.StandardButton# 警告对话框
warning(parent:QWidget, title:str, text:str, buttons:QMessageBox.StandardButton=QMessageBox.StandardButton.Ok, defaultButton:QMessageBox.StandardButton=QMessageBox.StandardButton.NoButton) -> QMessageBox.StandardButton# 错误对话框
critical(parent:QWidget, title:str, text:str, buttons:QMessageBox.StandardButton=QMessageBox.StandardButton.Ok, defaultButton:QMessageBox.StandardButton=QMessageBox.StandardButton.NoButton) -> QMessageBox.StandardButton

  信息对话框的创建方法有两种：一种是先创建信息对话框的实例对象，然后往实例对象中添加文本、图标和按钮，最后用 show()、open() 或 exec() 方法把信息对话框显示出来；另一种是用 QMessageBox 提供的静态函数来创建信息对话框。

  信息对话框上显示的文本分为 text、informativeText 和 detailedText，如果设置了 detailedText，会出现 “Show Details...” 按钮，这 3 个文本分别用 setText(str)、setInformativeText(str) 和 setDetailedText(str) 方法设置。detailedText 文本只能以 纯文本 形式显示，text 和 informativeText 文本可以用 纯文本 或 富文本 的形式显示。用 setTextFormat(Qt.TextFormat) 方法设置是用纯文本还是富文本显示，其中参数 Qt.TextFormat 可以取值如下：

Qt.TextFormat.PlainText       # 纯文本
Qt.TextFormat.RichText        # 富文本
Qt.TextFormat.AutoText        # 由系统决定
Qt.TextFormat.MarkdownText    # Markdown文本

  信息对话框的图标可以由用户自己定义，也可以使用 QMessageBox 提供的标准图标。自定义图标需要用 setIconPixmap(QPixmap) 方法定义，标准图标用 setIcon(QMessageBox.Icon) 方法设置，其中 QMessageBox.Icon 可以取值如下：

QMessageBox.Icon.NoIcon
QMessageBox.Icon.Question
QMessageBox.Icon.Information
QMessageBox.Icon.Warning
QMessageBox.Icon.Critical

  这几种图标的样式如下所示：

  信息对话框的按钮分为自定义按钮和标准按钮，不论哪种按钮都要赋予角色，按钮的角色用来说明按钮的作用。按钮的角色由枚举类型 QMessageBox.ButtonRole 确定，QMessageBox.ButtonRole 可以取的值下所示：

QMessageBox.ButtonRole.InvalidRole          # 不起作用的按钮
QMessageBox.ButtonRole.AcceptRole           # 接受对话框内的信息，例如OK按钮
QMessageBox.ButtonRole.RejectRole           # 拒绝对话框内的信息，例如Cancel按钮
QMessageBox.ButtonRole.DestructiveRole      # 重构对话框
QMessageBox.ButtonRole.ActionRole           # 使对话框内的控件产生变化
QMessageBox.ButtonRole.HelpRole             # 显示帮助的按钮
QMessageBox.ButtonRole.YesRole              # Yes按钮
QMessageBox.ButtonRole.NoRole               # No按钮
QMessageBox.ButtonRole.ResetRole            # 重置按钮，恢复对话框的默认值
QMessageBox.ButtonRole.ApplyRole            # 确认当前的设置，例如Apply按钮

  在信息对话框中添加的按钮可以是自定义的按钮，也可以是标准按钮。用 addButton(button:QAbstractButton,role:QMessageBox.ButtonRole) 方法或 addButton(text:str,QMessageBox.ButtonRole) 方法自定义按钮，前者将一个已经存在的按钮加入到对话框中，后者创建名称是 text 的按钮，同时返回该按钮；用 addButton(QMessageBox.StandardButton) 方法可以添加标准按钮，并返回按钮，添加按钮后可以为按钮设置槽函数。标准按钮已经有角色，参数 QMessageBox.StandardButton 用于设置标准按钮，标准按钮与其对应的角色如下所示。

QMessageBox.StandardButton.Ok                   # AcceptRole
QMessageBox.StandardButton.Open                 # AcceptRole
QMessageBox.StandardButton.Save                 # AcceptRole
QMessageBox.StandardButton.SaveAll              # AcceptRole
QMessageBox.StandardButton.Retry                # AcceptRole
QMessageBox.StandardButton.Ignore               # AcceptRoleQMessageBox.StandardButton.Cancel               # RejectRole
QMessageBox.StandardButton.Close                # RejectRole
QMessageBox.StandardButton.Abort                # RejectRoleQMessageBox.StandardButton.Discard              # DestructiveRoleQMessageBox.StandardButton.Apply                # ApplyRoleQMessageBox.StandardButton.Reset                # ResetRole
QMessageBox.StandardButton.RestoreDefaults      # ResetRoleQMessageBox.StandardButton.Help                 # HelpRoleQMessageBox.StandardButton.Yes                  # YesRole
QMessageBox.StandardButton.YesToAll             # YesRoleQMessageBox.StandardButton.No                   # NoRole
QMessageBox.StandardButton.NoToAll              # NoRole

  默认按钮是按 Enter 键时执行动作的按钮，默认按钮用 setDefaultButton(QPushButton) 方法或 setDefaultButton(QMessageBox.StandardButton) 方法设置，若未指定，则根据按钮的角色来确定默认按钮。Esc 按钮是按 Esc 键时执行动作的按钮，Esc 按钮用 setEscapeButton(QAbstractButton) 方法或 setEscapeButton(QMessageBox.StandardButton) 方法设置。如果没有设置 Esc 按钮，则将角色是 CancelRole 的按钮作为 Esc 按钮；如果只有一个按钮，则将这个按钮作为 Esc 按钮。

  对话框上被单击的按钮可以用 clickedButton() 方法获得，也可通过信号 buttonClicked(QAbstractButton) 获得，单击按钮后发送该信号，并传递被单击的按钮。

  我们可以用静态函数快速构建信息对话框，这些静态函数的格式如下。除 about() 函数外，其他函数返回值是被单击的按钮或按钮的角色识别号。

  PySide 中内置的 5 种不同类型的对话框在使用时是类似的，这里以消息对话框为例。

information(parent:QWidget, title:str, text:str, buttons:QMessageBox.StandardButton=QMessageBox.StandardButton.Ok, defaultButton:QMessageBox.StandardButton=QMessageBox.StandardButton.NoButton) -> Union[int, QMessageBox.StandardButton]

• parent：表示该窗口所属的窗口；
• title：字符串，表示对话框的标题；
• text：字符串，表示对话框中的提示内容；
• buttons：对话框上要添加的按钮，多个按钮之间用 "|" 来连接。没有指定该值是，默认为 OK 按钮；
• defaultButton：默认选中的按钮，没有指定该值时，默认为第一个按钮；

  用 QMessageBox 类常用信号如下：

buttonClicked(button:QAbstractButton)     # 单击任意按钮时发射信号，参数是被单击的按钮

import sysfrom PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QMessageBox
from PySide6.QtWidgets import QHBoxLayout, QPushButtonclass MyWidget(QWidget):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建布局layout = QHBoxLayout(self)# 3.消息对话框button_1 = QPushButton("消息对话框")layout.addWidget(button_1)button_1.clicked.connect(self.info)# 4.问答对话框button_2 = QPushButton("问答对话框")layout.addWidget(button_2)button_2.clicked.connect(self.quesstion)# 5.警告对话框button_3 = QPushButton("警告对话框")layout.addWidget(button_3)button_3.clicked.connect(self.warning)# 6.错误对话框button_4 = QPushButton("错误对话框")layout.addWidget(button_4)button_4.clicked.connect(self.critical)# 7.关于对话框button_5 = QPushButton("关于对话框")layout.addWidget(button_5)button_5.clicked.connect(self.about)def info(self):select = QMessageBox.information(self, "消息", "这是一个消息对话框", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)if select == QMessageBox.StandardButton.Yes:QMessageBox.information(self, "提醒", "你点击的确定按钮")elif select == QMessageBox.StandardButton.No:QMessageBox.information(self, "提醒", "你点击的取消按钮")def quesstion(self):QMessageBox.question(self, "问答", "这是一个问答对话框", QMessageBox.StandardButton.Ok)def warning(self):QMessageBox.warning(self, "警告", "这是一个警告对话框", QMessageBox.StandardButton.Ok)def critical(self):QMessageBox.critical(self, "错误", "这是一个错误对话框", QMessageBox.StandardButton.Ok)def about(self):QMessageBox.about(self, "关于", "这是一个关于对话框")if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

QMessageBox.about() 关于对话框不能指定按钮；

三、错误对话框

  错误信息对话框 QErrorMessage 用于将程序运行时出现的错误内容显示出来。错误信息对话框由一个显示信息的文本框和一个勾选按钮构成。

  使用 QErrorMessage 类创建错误信息对话框实例的方法如下：

QErrorMessage(parent:QWidget=None)

  错误信息对话框只有两个重载型槽函数 showMessage(message:str) 和 showMessage(message:str,type:str) ，执行该方法后立即显示对话框，其中 message 参数是 错误信息，type 参数指定 错误信息的类型。如果用户在对话框中不勾选 “Show this message again”，则遇到相同的错误信息或相同类型的错误信息时，将不再弹出对话框。

import sysfrom PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QErrorMessageclass MyWidget(QWidget):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建错误对话框errorMessage = QErrorMessage(self)# 3.错误对话框的显示信息errorMessage.showMessage("程序突然崩溃", "未知错误")if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

四、文件对话框

  文件对话框 QFileDialog 用于打开或保存文件时获取文件路径和文件名。在文件对话框中可以根据文件类型对文件进行过滤，只显示具有某些扩展名的文件。文件对话框的界面分为两种，一种是 PySide6 提供的界面，另一种是本机操作系统提供的界面，可以通过文件对话框的 setOption(QFileDialog.DontUseNativeDialog,bool) 方法设置显示的是哪种界面。对话框上的标签和按钮名称都可以通过对话框的属性进行修改。

  用 QFileDialog 类创建文件对话框实例的方法如下所示：

QFileDialog(parent:QWidget=None, f:Qt.WindowFlags)
QFileDialog(parent:QWidget=None, caption:str='', directory:str='', filter:str='')

  其中，caption 用于设置 对话框的标题，directory 设置 默认路径，filter 设置 过滤方式，只显示具有某种扩展名的文件。

  用 QFileDialog 类常用方法如下：

# 实例方法
setAcceptMode(mode:QFileDialog.AcceptMode) -> None                  # 设置是打开还是保存对话框
setDefaultSuffix(suffix:str) -> None                                # 设置默认的后缀名
defaultSuffix() -> str:                                             # 返回默认的后缀名saveState() -> QByteArray:                                          # 保存对话框状态到QByteArray
restoreState(state:QByteArray) -> bool                              # 从QByteArray恢复对话框状态setNameFilter(filter:str) -> None                                   # 根据文件的扩展名设置过滤器
setNameFilters(filters:Sequence[str]) -> None                       # 设置过滤器列表
nameFilters() -> List[str]:                                         # 获取过滤器列表selectFile(filename:str) -> None                                    # 设置初始选中的文件，可当作默认文件
selectedFiles() -> List[str]:                                       # 获取被选中文件的绝对文件路径列表，如果没有选择文件，则返回值只有路径
selectNameFilter(filter:str) -> None                                # 设置对话框初始名称过滤器
selectedNameFilter() -> str:                                        # 获取被选中的名称过滤器
selectUrl(url:Union[QUrl, str]) -> None                             # 设置对话框初始选中的文件
selectedUrls() -> List[QUrl]:                                       # 获取被选中的文件的绝对文件路径列表，如果没有选择文件，则返回值只有路径directory() -> QDir:                                                # 获取对话框的当前路径
directoryUrl() -> QUrl:                                             # 获取对话框的当前路径
setDirectory(directory:Union[QDir, str]) -> None                    # 设置对话框的初始路径setFileMode(mode:QFileDialog.FileMode) -> None                      # 设置文件模式，对话框是用于选择路径、单选个文件还是多个文件setHistory(paths:Sequence[str]) -> None                             # 设置对话框的浏览记录
history() -> List[str]                                              # 获取对话框的浏览记录setLabelText(label:QFileDialog.DialogLabel, text:str) -> None       # 设置对话框上各标签或按钮的名称
labelText(label:QFileDialog.DialogLabel) -> str:                    # 获取对话框上标签或按钮的名称setOption(option:QFileDialog.Option, on:bool=true) -> None          # 设置对话框选项
testOption(option:QFileDialog.Option) -> bool                       # 测试对话框选项setViewMode(mode:QFileDialog.ViewMode) -> None                      # 设置视图模式，对话框是显示文件列表还是显示图标# 静态方法# 打开文件对话框，获取路径或文件及过滤器
# 其中，caption是对话框的标题，dir是初始路径，fiilter是对话框中可选的过滤器，selectedFilter是对话框中已经选中的过滤器
# 除了getExistingDirectory()和getExistingDirectoryUrl()外，其它方法都是返回元组，元组的第一个参数是文件名或文件名列表，第二个参数是选中的过滤器
getExistingDirectory(parent:QWidget=None, caption:str='', dir:str='', options:QFileDialog.Option=QFileDialog.Option.ShowDirsOnly) -> strgetExistingDirectoryUrl(parent:QWidget=None, caption:str='', dir:Union[QDir, str]=Default(QUrl), options:QFileDialog.Option=QFileDialog.Option.ShowDirsOnly) -> QUrlgetOpenFileName(parent:QWidget=None, caption:str='', dir:str='', filter:str='', selectedFilter:str='', options:QFileDialog.Options=QFileDialog.Options()) -> TuplegetOpenFileNames(parent:QWidget=None, caption:str='', dir:str='', filter:str='', selectedFilter:str='', options:QFileDialog.Options=QFileDialog.Options()) -> TuplegetOpenFileUrl(parent:QWidget=None, caption:str='', dir:Union[QDir, str]='', filter:str=Default(QUrl), selectedFilter:str='', options:QFileDialog.Options=QFileDialog.Options()) -> TuplegetOpenFileUrls((parent:QWidget=None, caption:str='', dir:Union[QDir, str]='', filter:str=Default(QUrl), selectedFilter:str='', options:QFileDialog.Options=QFileDialog.Options()) -> TuplegetSaveFileName(parent:QWidget=None, caption:str='', dir:str='', filter:str='', selectedFilter:str='', options:QFileDialog.Option=QFileDialog.Option.ShowDirsOnly) -> TuplegetSaveFileUrl((parent:QWidget=None, caption:str='', dir:Union[QDir, str]='', filter:str=Default(QUrl), selectedFilter:str='', options:QFileDialog.Options=QFileDialog.Options()) -> Tuple

  文件对话框也用 show()、open() 和 exec() 方法显示，最简便的方法是用 QFileDialog 提供的静态方法来打开文件对话框获取文件路径和文件名。

  用 setFileMode(QFileDialog.FileMode) 方法可以设置对话框的文件模式，文件模式是指对话框显示的内容或允许选择的内容，其中参数 QFileDialog.FileMode 可以取值如下：

QFileDialog.FileMode.AnyFile        # 任意文件和文件夹，也可以输入不存在的文件或文件夹
QFileDialog.FileMode.ExistingFile   # 只能选择一个存在的文件，不能是文件夹或不存在的文件
QFileDialog.FileMode.Directory      # 只能选择文件夹
QFileDialog.FileMode.ExistingFiles  # 可以选择多个存在的文件

  用 setOption(QFileDialog.Option,on=True) 方法设置文件对话框的外观选项，需在显示对话框之前设置，参数 QFileDialog.Option可以取值如下：

QFileDialog.Option.ShowDirsOnly                   # 只显示文件夹
QFileDialog.Option.DontResolveSymlinks            # 不解析链接
QFileDialog.Option.DontConfirmOverwrite           # 存盘时若选择了存在的文件，不提示覆盖信息
QFileDialog.Option.DontUseNativeDialog            # 不使用操作系统的对话框
QFileDialog.Option.ReadOnly                       # 只读
QFileDialog.Option.HideNameFilterDetails          # 隐藏名称过滤器的详细信息
QFileDialog.Option.DontUseCustomDirectoryIcons    # 不使用用户的目录图标，有些系统允许使用）。

  用 setAcceptMode(QFileDialog.AcceptMode) 方法设置文件对话框是打开对话框还是保存对话框，参数 QFileDialog.AcceptMode可取值如下：

QFileDialog.AcceptMode.AcceptOpen    # 设置文件对话框为打开模式，这是默认值
QFileDialog.AcceptMode.AcceptSave    # 设置文件对话框为保存模式

  用 setViewMode(QFileDialog.ViewMode) 方法设置对话框的视图模式，参数 QFileDialog.ViewMode 可取值如下：

QFileDialog.ViewMode.Detail    # 详细显示
QFileDialog.ViewMode.List      # 列表显示，只显示图标和名称

  对话框上的标签和按钮的文字可以用 setLabelText(QFileDialog.DialogLabel,str) 方法重新设置，其中参数 QFileDialog.DialogLabel 可以取值如下：

QFileDialog.DialogLabel.LookIn
QFileDialog.DialogLabel.FileName
QFileDialog.DialogLabel.FileType
QFileDialog.DialogLabel.Accept
QFileDialog.DialogLabel.Reject

  设置过滤器 filter。过滤器的作用是在文件对话框中只显示某些类型的文件，例如通过方法 setNameFilter(＂Picture(*.png*.bmp*.jpeg*.jpg＂) 设置过滤器后，对话框只显示扩展名为 png、bmp、jpeg 和 jpg的文件。创建过滤器时，过滤器之间用空格隔开，如果有括号，则用括号中的内容作为过滤器，多个过滤器用两个分号 ;;隔开，例如 setNameFilter("Picture(*.png*.bmp);;text(*.txt)")。用 setNameFilter(str) 方法或 setNameFilters(Sequence[str]) 方法设置对话框中的过滤器。

  用 QFileDialog 类常用信号如下：

currentChanged(path:str)                # 在对话框中所选择的文件或路径发生改变时发射信号，参数是当前选择的文件或路径
currentUrlChanged(url:QUrl)             # 在对话框中所选择的文件或路径发生改变时发射信号，参数是当前选择的文件或路径的QUrl对象
directoryEntered(directory:str)         # 进入新路径时发射信号，参数是新路径的字符串
directoryUrlEntered(directory:QUrl)     # 进入新路径时发射信号，参数是新路径的QUrl对象
fileSelected(file:str)                  # 单击open或save按钮后发射信号，参数是选中的文件
filesSelected(files:List[str])          # 单击open或save按钮后发射信号，参数是选中的文件列表
urlSelected(url:QUrl)                   # 单击open或save按钮后发射信号，参数是选中的文件的QUrl对象
urlsSelected(urls:List[QUrl])           # 单击open或save按钮后发射信号，参数是选中的文件的QUrl对象列表
filterSelected(filter:str)              # 选择新的过滤器后发射信号，参数是新的过滤器

import sysfrom PySide6.QtWidgets import QApplication, QMainWindow
from PySide6.QtWidgets import QFileDialog
from PySide6.QtWidgets import QPushButton, QListWidgetclass MyWidget(QMainWindow):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建一个按钮控件button = QPushButton("选择文件", self)button.setGeometry(0, 0, 100, 30)# 3.创建一个列表控件self.listWidget = QListWidget(self)self.listWidget.setGeometry(0, 50, 500, 300)# 4.为按钮的clicked信号绑定槽函数button.clicked.connect(self.bind_list)def bind_list(self):# 1.创建文件对话框fileDialog = QFileDialog()# 2.设置多选fileDialog.setFileMode(QFileDialog.FileMode.ExistingFiles)# 4.设置初始磁盘fileDialog.setDirectory("E:\\")# 5.设置文件过滤器fileDialog.setNameFilter("图片文件(*.jpg *.png);;视频文件(*.mp4 *.ts *.avi)")# 6.判断是否选择了文件if fileDialog.exec():# 向列表控件中添加项self.listWidget.addItems(fileDialog.selectedFiles())if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

五、输入对话框

  输入对话框 QInputDialog 用于输入简单内容或选择内容，分为整数输入框、浮点数输入框、文本输入框、多行文本输入框和下拉列表输入框 5 种。输入对话框由一个标签、一个输入控件和两个按钮构成。如果是整数输入框，输入控件是 QSpinBox；如果是浮点数输入框，输入控件是 QDoubleSpinBox；如果是单行文本输入框，输入控件是 QLineEdit；如果是多行文本输入框，输入控件是 QPlainTextEdit；如果是下拉列表输入框，输入控件是 QComboBox 或 QListView。输入框的类型用 setInputMode(QInputDialog.InputMode) 方法设置。

  使用 QInputDialog 类创建输入对话框实例的方法如下所示：

QInputDialog(parent:QWidget=None, flags:Qt.WindowFlags=Default(Qt.WindowFlags))

  用 QInputDialog 类常用方法如下：

# 实例方法
setInputMode(mode:QInputDialog.Mode) -> None                    # 设置输入对话框的类型
setOption(option:QInputDialog.Option, on:bool=true) -> None     # 设置输入对话框的参数
testOption(option:QInputDialog.Option) -> bool                  # 测试输入对话框的参数
setLabelText(text:str) -> None                                  # 设置对话款中标签的名称给
setOkButtonText(text:str) -> None                               # 设置对话框中的确定按钮的名称
setCancelButtonText(text:str) -> None                           # 设置对话框中的取消按钮的名称setIntValue(value:int) -> None                                  # 设置对话框中的整数输入框的值
intValue() -> int                                               # 获取对话框中的整数输入框的值
setIntMinimum(min:int) -> None                                  # 设置对话框中的整数输入框的最小值
setIntMaximum(max:int) -> None                                  # 设置对话框中的整数输入框的最大值
setIntRange(min:int, max:int) -> None                           # 设置对话框中的整数输入框的范围
setIntStep(step:int) -> None                                    # 设置对话框中的整数输入框的步长setDoubleValue(value:float) -> None                             # 设置对话框中的浮点数输入框的值
doubleValue() -> float                                          # 获取对话框中的浮点数输入框的值
setDoubleDecimals(decimals:int) -> None                         # 设置对话框中的浮点数输入框的小数位数
setDoubleMinimum(min:float) -> None                             # 设置对话框中的浮点数输入框的最小值
setDoubleMaximum(max:float) -> None                             # 设置对话框中的浮点数输入框的最大值
setDoubleRange(min:float, max:float) -> None                    # 设置对话框中的浮点数输入框的范围
setDoubleStep(step:float) -> None                               # 设置对话框中的浮点数输入框的步长setTextValue(text:str) -> None                                  # 设置对话框中的文本输入框的值
textValue() -> str                                              # 获取对话框中的文本输入框的值
setTextEchoMode(mode:QLineEdit.EchoMode) -> None                # 设置对话框中的文本输入框的输入方式setComboBoxItems(items:Sequence[str]) -> None                   # 设置对话框中的下拉列表框的选项
comboBoxItems() -> List[str]                                    # 获取对话框中的下拉列表框的选项
setComboBoxEditable(editable:bool) -> None                      # 设置对话框中的下拉列表框是否可编辑# 静态方法
# 显示输入对话框，并返回输入的值和单击按钮的类型
# 其中，title是设置对话框的标题名称，label是对话框中标签的名称
# 在对话框中点击OK按钮后，返回值是元组(输入值, True)
# 在对话框中点击Cancel按钮后，返回值是元组(0, False)或("", False)
getInt(parent:QWidget, title:str, label:str, value:int=0, minValue:int=-2147483647, maxValue:int=2147483647, step:int=1, flags:Qt.WindowFlags=Qt.WindowFlags()) -> Tuple[int, bool]getDouble(parent:QWidget, title:str, label:str, value:float=0, minValue:float=-2147483647, maxValue:float=2147483647, decimals:int=1, flags:Qt.WindowFlags=Qt.WindowFlags(), step:float=1) -> Tuple[float, bool]getText(parent:QWidget, title:str, label:str, echo:QLineEdit.EchoMode=QLineEdit.Normal, text:str="", flags:Qt.WindowFlags=Qt.WindowFlags(), inputMethodHints=Qt.ImhNone) -> Tuple[str, bool]getMultiLineText(parent:QWidget, title:str, label:str, text:str="", flags:Qt.WindowFlags=Qt.WindowFlags(), inputMethodHints=Qt.ImhNone) -> Tuple[str, bool]getItem(parent:QWidget, title:str, label:str, items:Sequence[str], current:int=0, editable:bool=true, flags:Qt.WindowFlags=Qt.WindowFlags(), inputMethodHints=Qt.ImhNone)

  输入对话框分为 整数输入对话框、浮点数输入对话框 和 文本输入对话框，其中 文本输入对话框 又分为 单行文本输入对话框、多行文本输入对话框 和 列表输入对话框，列表输入对话框 通常是从 QComboBox 控件或 QListWiew 控件中选择内容。用 setInputMode(QInputDialog.InputMode) 方法设置输入对话框的类型，其中参数 QInputDialog.InputMode可以取值如下：

QInputDialog.InputMode.IntInput          # 整数输入对话框
QInputDialog.InputMode.Double            # 浮点数输入对话框
InputQInputDialog.InputMode.TextInput    # 文本输入对话框

  对于整数输入对话框，用 setIntValue(int) 方法可以设置对话框初次显示时的值，用 intValue() 方法可以获取单击 OK 按钮后的整数值。整数输入对话框中允许输入值的范围用 setIntMinimum(int)、setIntMaximum(int) 方法设置，或者用 setIntRange(int,int) 方法设置。整数输入对话框的输入控件是 QSpinBox，单击右侧上下箭头可微调整数，微调整数值变化的步长用 setIntStep(int) 方法设置。

  对于浮点数输入对话框，用 setDoubleValue(float) 方法可以设置对话框初次显示时的值，用 doubleValue() 方法可以获取单击 OK 按钮后的浮点数值。浮点数对话框中允许输入值的范围用 setDoubleMinimum(float)、setDoubleMaximum(float) 方法设置，或者用 setDoubleRange(float,float) 方法设置。浮点数对话框的输入控件是 QDoubleSpinBox，单击右侧上下箭头可微调数据，浮点数值变化的步长用 setDoubleStep(float) 方法设置。

  对于文本输入对话框，默认的输入控件是 QLineEdit，用 setOption(QInputDialog.UsePlainTextEditForTextInput) 方法将 QLineEdit 控件替换成 QPlainTextEdit，当用 setComboBoxItems(Sequence[str]) 方法设置控件的项（item）时，输入控件替换成 QComboBox，如果设置成 setOption(QInputDialog.UseListViewForComboBoxItems)，则输入控件替换成 QListView。

  对于文本输入对话框，用 setTextValue(str) 方法可以设置对话框中初始文本，用 textValue() 方法获取单击 OK 按钮后输入对话框的值。当输入控件是 QLineEdit 时，用 setTextEchoMode(QLineEdit.EchoMode) 方法可以设置 QLineEidt 控件的输入模式，其中 QLineEdit.EchoMode 可以取值如下：

QLineEdit.EchoMode.Norma                 # 正常显示
QLineEdit.EchoMode.NoEcho                # 输入文字时，没有任何显示
QLineEdit.EchoMode.Password              # 输入文字时，按照密码方式显示
QLineEdit.EchoMode.PasswordEchoOnEdit    # 失去焦点时，密码显示状态，编辑文本时，正常显示

  我们可以使用 getText() 方法显示一个用于输入字符串的文本框控件。

text, flag = getText(parent, title, label, echo=QLineEdit.Normal, text="", flags=Qt.WindowFlags(), inputMethodHints=Qt.ImhNone)

  参数说明：

• parent：父窗口对象
• title：QInputDialog 的标题
• label：QInputDialog 内部显示的文本
• echo：文本编辑框内容的显示方式
• text：默认显示文本

  该方法返回一个元组，元组的第一个元素 text 表示文本编辑框内的字符串，第二个元素 flag 表示是否正常返回。

  我们可以使用 getItem() 方法显示一个 ComboBox 下拉列表控件，用户可以从中选择数据。

text, flag = getItem(parent, title, label, items, current=0, editable=true, flags=Qt.WindowFlags(), inputMethodHints=Qt.ImhNone)

  参数说明：

• parent：父窗口对象
• title：QInputDialog 的标题
• label：QInputDialog 内部显示的文本
• items：QComboBox 控件的内容列表
• current：默认显示 QComboBox 组件中的某一个索引的内容
• editable：QComboBox 是否可以被编辑

  该方法返回一个元组，元组的第一个元素 text 表示从 QComboBox 下拉列表中选择的内容，第二个元素 flag 表示是否正常返回。

  我们可以使用 getInt() 方法显示一个用于输入整数的编辑框，显示的是 QSnipBox 控件。

value, flag = getInt(parent, title, label, value=0, minValue=-2147483647, maxValue=2147483647, step=1, flags=Qt.WindowFlags())

  参数说明：

• parent：父窗口对象
• title：QInputDialog 的标题
• label：QInputDialog 内部显示的文本
• value：QSnipBox 控件的默认值
• minValue：QSnipBox 控件的最小值
• maxValue：QSnipBox 控件的最大值
• step：QSnipBox 控件的单步值

  该方法返回一个元组，元组的第一个元素 value 表示从 QSnipBox 控件中选择的整数值，第二个元素 flag 表示是否正常返回。

  我们可以使用 getDouble() 方法显示一个用于输入浮点数的编辑框，显示的是 QDoubleSnipBox 控件。

value, flag = getDouble(parent, title, label, value=0, minValue=-2147483647, maxValue=2147483647, decimals=1, flags=Qt.WindowFlags(), step=1)

  参数说明：

• parent：父窗口对象
• title：QInputDialog 的标题
• label：QInputDialog 内部显示的文本
• value：QDoubleSnipBox 控件的默认值
• minValue：QDoubleSnipBox 控件的最小值
• maxValue：QDoubleSnipBox 控件的最大值
• decimals：QDoubleSnipBox 控件的单步值

  该方法返回一个元组，元组的第一个元素 value 表示从 QDoubleSnipBox 控件中选择的小数值，第二个元素 flag 表示是否正常返回。

  用 QInputDialog 类常用信号如下：

intValueChanged(value:int)              # 输入对话框的整数值改变时发射信号
intValueSelected(value:int)             # 单击OK按钮后发射信号
doubleValueChanged(value:float)         # 输入对话框的浮点数值改变时发射信号
doubleValueSelected(value:float)        # 单击OK按钮后发射信号
textValueChanged(text:str)              # 输入对话框的文本改变时发射信号
textValueSelected(text:str)             # 单击OK按钮后发射信号

import sysfrom PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QInputDialog
from PySide6.QtWidgets import QGridLayout
from PySide6.QtWidgets import QLabel, QLineEditclass MyWidget(QWidget):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)layout = QGridLayout(self)# 添加姓名标签name_label = QLabel("姓名")layout.addWidget(name_label, 0, 0)# 添加姓名文本框self.name_text = QLineEdit()self.name_text.setPlaceholderText("请输入姓名")layout.addWidget(self.name_text, 0, 1)self.name_text.textEdited.connect(self.get_name)# 添加性别标签gender_label = QLabel("性别")layout.addWidget(gender_label, 1, 0)# 添加性别文本框self.gender_text = QLineEdit()self.gender_text.setPlaceholderText("请输入性别")layout.addWidget(self.gender_text, 1, 1)self.gender_text.textEdited.connect(self.get_gender)# 添加年龄标签age_label = QLabel("年龄")layout.addWidget(age_label, 2, 0)# 添加年龄文本框self.age_text = QLineEdit()self.age_text.setPlaceholderText("请输入年龄")layout.addWidget(self.age_text, 2, 1)self.age_text.textEdited.connect(self.get_age)# 添加分数标签score_label = QLabel("分数")layout.addWidget(score_label, 3, 0)# 添加分数文本框self.score_text = QLineEdit()self.score_text.setPlaceholderText("请输分数")layout.addWidget(self.score_text, 3, 1)self.score_text.textEdited.connect(self.get_score)def get_name(self):name, flag = QInputDialog.getText(self, "姓名", "请输入姓名", QLineEdit.EchoMode.Normal, "小樱")if flag:self.name_text.setText(name)def get_gender(self):gender, flag = QInputDialog.getItem(self, "性别", "请输入选择性别", ("男", "女"), 1, False)if flag:self.gender_text.setText(gender)def get_age(self):age, flag = QInputDialog.getInt(self, "年龄", "请输入年龄", 0, 0, 100, 1)if flag:self.age_text.setText(str(age))def get_score(self):scrore, flag = QInputDialog.getDouble(self, "分数", "请输入分数", 0, 0, 100, 1)if flag:self.score_text.setText(str(scrore))if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

六、字体对话框

  字体对话框 QFontDialog 用于选择字体，其界面是 PySide6 已经编辑好的，用户可以直接在对话框中选择与字体有关的选项。

  用 QFontDialog 类创建标准字体对话框的方法如下，其中 QFont 用于初始化对话框。

QFontDialog(parent:QWidget=None)
QFontDialog(font:QFont, parent:QWidget=None)

  QFontDialog 类表示字体对话框，用户可以从中选择字体的大小、样式、格式等信息。QFontDialog 类中常用的方法如下：

# 实例方法
selectedFont() -> QFont                                                   # 获取在对话框中单击OK按钮后，最终选中的字体
setCurrentFont(font:QFont) -> None                                        # 设置字体对话框中当前的字体，用于初始化字体对话框
currentFont() -> QFont                                                    # 获取字体对话框中当前的字体
setOption(option:QFontDialog.FontDialogOption, on:bool=true) -> None      # 设置对话框的选项
testOption(option:QFontDialog.FontDialogOption) -> bool                   # 测试对话框的选项# 静态方法
# 用模式方式初始化对话框，获取字体
# 参数initial是初始化字体，title是对话框标题
# 返回值是元组，第一个是是否成功，第二个是字体
# 如在对话框中单击OK按钮，bool为True，单击Cancel按钮，bool为False
getFont(parent:QWidget=None) -> Tuple[bool, QFont]
getFont(initial:QFont, parent:QWidget=None, title:str="", options:QFontDialog.FontDialogOption=QFontDialog.FontDialogOptions()) -> Tuple[bool, QFont]

  创建字体对话框的一种方法是先创建对话框实例对象，设置对话框的属性，然后用 show()、open() 或 exec() 方法显示对话框；另一种方法是直接用 getFont() 方法，getFont() 方法是静态方法，可直接使用 类名.getFont() 方法调用，也可用实例对象调用。

  用 setOption(QFontDialog.FontDialogOption,on=True) 方法设置字体对话框的选项，其中QFontDialog.FontDialogOption 可以取值如下：

QFontDialog.FontDialogOption.NoButtons               # 不显示OK和Cancel按钮
QFontDialog.FontDialogOption.DontUseNativeDialog     # 在Mac机上不使用本机字体对话框，使用PySide6的字体对话框
QFontDialog.FontDialogOption.ScalableFonts           # 显示可缩放字体
QFontDialog.FontDialogOption.NonScalableFonts        # 显示不可缩放字体
QFontDialog.FontDialogOption.MonospacedFonts         # 显示等宽字体
QFontDialog.FontDialogOption.ProportionalFonts       # 显示比例字体

  用 selectedFont() 方法可以获取在单击 OK 按钮后，最终选中的字体。在对话框中单击 OK 按钮时，同时也发送信号 fontSelected(QFont)，其中参数 QFont 是最后选中的字体。

  用 setCurrentFont(QFont) 方法可以设置对话框显示时，初始选中的字体。在对话框中选择不同的字体时，会发送 currentFontChanged(QFont) 信号，其中参数 QFont 是当前选中的字体。

  QFontDialog 类中常用的信号如下：

currentFontChanged(font:QFont)          # 在对话框中选择字体是发射信号
fontSelected(font:QFont)                # 在对话框中单击OK按钮是发射信号

import sysfrom PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QFontDialog
from PySide6.QtWidgets import QPushButton, QTextEditclass MyWidget(QWidget):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建按钮控件，用于点击后弹出字体对话框font_button = QPushButton("选择字体", self)font_button.setGeometry(0, 0, 100, 30)font_button.clicked.connect(self.set_font)# 3.创建文本框控件，用于显示文本self.textEdit = QTextEdit(self)self.textEdit.setGeometry(0, 50, 500, 300)self.textEdit.setText("小樱")def set_font(self):flag, font = QFontDialog.getFont()if flag:self.textEdit.setFont(font)if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

七、颜色对话框

  颜色对话框 QColorDialog 和字体对话框 QFontDialog 类似，也是一种标准对话框，供用户选择颜色。在对话框中用户可以自己设定和选择颜色，还可使用标准颜色，另外用户也可保存自己设定的颜色。

  用 QColorDialog 类创建标准颜色对话框的方法如下：

QColorDialog(parent:QWidget=None)
QColorDialog(color:QColor, parent:QWidget=None)

  其中参数 QColor 用于 初始化对话框，还可以用 Qt.GlobalColor 和 QGradient 初始化颜色。

  QColorDialog 类中常用的方法如下：

# 实例方法
selectedColor() -> QColor                                                   # 获取颜色对话框中单击OK按钮后选中的颜色
setCurrentColor(color: QColor) -> None                                      # 设置颜色对话框中当前选中的颜色，用于初始化对话框
currentColor() -> QColor                                                    # 获取颜色对话框中当前选中的颜色
setOption(option:QColorDialog.ColorDialogOption, on:bool=true) -> None      # 设置对话框的选项
testOption(option:QColorDialog.ColorDialogOption) -> bool                   # 测试对话框的选项# 静态方法
setCustomColor(index:int, color:QColor) -> None                             # 设置用户颜色
customColor(index:int) -> QColor                                            # 获取用户颜色
customCount() -> int                                                        # 获取用户颜色数量
setStandardColor(index:int, color:QColor) -> None                           # 设置标准颜色
standardColor(index:int) -> QColor                                          # 获取标准颜色# 显示对话框获取颜色
getColor(initial:QColor=Qt.white, parent:QWidget=None, title:str="", options:QColorDialog.ColorDialogOptions=QColorDialog.ColorDialogOptions()) -> QColor

  颜色对话框的显示可以用 show()、open() 和 exec() 方法，也可以用 getColor() 方法。getColor() 方法是静态方法，直接使用 类名.getColor() 方法调用，也可用实例对象调用。

  用 setOption(QColorDialog.ColorDialogOption,on=True) 方法设置颜色对话框的选项，其中 QColorDialog.ColorDialogOption 可以取值如下：

QColorDialog.ColorDialogOption.ShowAlphaChannel    # 在对话框上显示Alpha通道
QColorDialog.ColorDialogOption.NoButtons           # 不显示OK和Cancel按钮
QColorDialog.ColorDialogOption.DontUseNativeDialog # 不使用本机的对话框

  颜色对话框中有标准的颜色，可以用 standardColor(index:int) 方法获取标准颜色，用 setStandardColor(index:int,QColor) 方法设置标准颜色。

  颜色对话框可以存储用户指定的颜色，用 setCustomColor(index:int,QColor) 方法设置用户颜色，用 customColor(index:int) 方法获取用户颜色。

  QColorDialog 类中常用的信号如下：

colorSelected(color:Color)                  # 在对话框中选择颜色是发射信号
currentColorChanged(color:Color)            # 在对话框中单击OK按钮是发射信号

import sysfrom PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QColorDialog
from PySide6.QtWidgets import QPushButton, QTextEditclass MyWidget(QWidget):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建按钮控件，用于点击后弹出颜色对话框font_button = QPushButton("选择颜色", self)font_button.setGeometry(0, 0, 100, 30)font_button.clicked.connect(self.set_color)# 3.创建文本框控件，用于显示文本self.textEdit = QTextEdit(self)self.textEdit.setGeometry(0, 50, 500, 300)self.textEdit.setText("小樱")def set_color(self):color = QColorDialog.getColor()if color.isValid():self.textEdit.setTextColor(color)if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

点击设置颜色之后，之前字体的颜色不会改变；

八、进度对话框

  进度对话框 QProgressDialog 用于表明某项任务正在进行及任务的完成进度。进度对话框由 1 个标签 QLabel、1 个进度条 QProgressBar 和 1 个按钮 QPushButton 构成。进度对话框可以与定时器一起工作，每隔一段时间获取一项任务的完成值，再设置进度条的当前值。当然，如果任务能自动输出其完成值，可直接与进度条的槽函数 setValue(int) 连接。

  用 QProgressDialog 类创建进度对话框的方法如下所示：

QProgressDialog(parent:QWidget=None)
QProgressDialog(title:str, text:str, min:int, max:int, parent:QWidget=None)

  QProgressDialog 类中常用的方法如下：

# 实例方法
minimumDuration() -> int                        # 获取从创建到显示时的时间
value() -> int                                  # 获取进度条的当前值
minimum() -> int                                # 获取进度条的最小值
maximum() -> int                                # 获取进度条的最大值
labelText() -> str                              # 获取对话框中标签的文本
wasCanceled() -> bool                           # 获取对话框是否被取消
setAutoClose(close:bool) -> None                # 调用reset()方法时，设置是否自动隐藏
autoClose() -> bool                             # 获取是否自动隐藏
setAutoReset(reset:bool) -> None                # 进度条的值达到最大时，设置是否自动重置
autoReset() -> bool                             # 获取进度条值达到最大时，是否自动重置
setBar(bar:QProgressBar) -> None                # 重新设置对话框中的设置进度条
setCancelButton(button:QPushButton) -> None     # 重新设置对话框中的取消按钮
setLabel(label:QLabel) -> None                  # 重新设置对话框中的标签# 槽函数
setMinimumDuration(ms:int) -> None              # 设置对话框从创建到显示出来的过滤时间
setValue(progress:int) -> int                   # 设置进度条的当前值
setMinimum(minimum:int) -> None                 # 设置进度条的最小值
setMaximum(maximum:int) -> None                 # 设置进度条的最大值
setRange(minimum:int, maximum:int) -> None      # 设置进度条的最小值和最大值
setLabelText(text:str) -> None                  # 设置对话框中标签的文本
setCancelButtonText(text:str) -> None           # 设置取消按钮的文本
cancel() -> str                                 # 取消对话框
forceShow() -> None                             # 强制显示对话框
reset() -> None                                 # 重置对话框

  进度对话框可以不用 show() 等方法来显示，在创建进度对话框后，经过某段时间后对话框会自动显示出来，这段时间是通过 setMinimumDuration(int) 来设置的。参数的单位是毫秒，默认是 4000 毫秒，如果设置为 0，则立即显示对话框。可以用 forceShow() 方法强制显示对话框。设置这个显示时间的目的是防止任务进展太快，进度对话框一闪而过。

  对话框如果设置了 setAutoClose(True)，调用 reset() 方法重置进度条时，会自动隐藏对话框。对话框如果设置了 setAutoReset(True)，则进度条的值达到最大值时会调用 reset() 方法重置进度条；

  当单击对话框中的 Cancel 按钮或执行 cancel() 方法时，会取消对话框，并且会重置和隐藏对话框，同时 wasCanceled() 的值为 True。

  QProgressDialog 类中常用的信号如下：

canceled()       # 单击对话框中的Cancel按钮后，发射信号，进度条被隐藏和重置

import sysfrom PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QProgressDialog
from PySide6.QtWidgets import QPushButton, QTextEdit
from PySide6.QtCore import QTimerclass MyWidget(QWidget):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()self.count = 0# 3.创建一个定时器对象self.timer = QTimer()# 4.关联信号self.timer.timeout.connect(self.change_progress)def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建按钮控件，点击后弹出进度对话框button = QPushButton("点击弹出进度对话框", self)button.clicked.connect(self.popup_progressDialog)def popup_progressDialog(self):# 1.创建进度对话框控件self.progressDialog = QProgressDialog(self)# 2.设置进度对话框的范围self.progressDialog.setRange(0, 100)# 3.设置当前值为0self.progressDialog.setValue(0)# 4.设置对话款从创建到出来的过渡时间self.progressDialog.setMinimumDuration(0)# 5.设置进度对话框的标签文本self.progressDialog.setLabelText("任务正在进行中")# 6.设置进度对话框的取消按钮文本self.progressDialog.setCancelButtonText("终止任务")# 7.设置对话框调用reset()方法时自动隐藏self.progressDialog.setAutoClose(True)# 8.设置进度条的值到达最大值,自动重置self.progressDialog.setAutoReset(True)# 9.定义信号与槽的连接self.progressDialog.canceled.connect(self.cancel_task)# 8.启动定时器self.timer.start(1000)def change_progress(self):# 如果进度对话框没有关闭if not self.progressDialog.wasCanceled():self.count += 1if self.count <= 100:self.progressDialog.setValue(self.count)else:# 计数值清零self.count = 0# 关闭定时器self.timer.stop()else:# 计数值清零self.count = 0# 关闭定时器self.timer.stop()def cancel_task(self):print("你手动终止了任务")if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())

九、向导对话框

  向导对话框 QWizard 由多页构成，可以引导客户按步骤完成某项工作。对话框的顶部是横幅（banner），横幅中有标题、子标题和 logo，左侧是水印区（watermark），底部有一排按钮，右侧是向导页的内容；与其他对话框不同的是，向导对话框由多页构成，同一时间只能显示其中的一页，单击 Next 按钮或 Back 按钮可以向后或向前显示其他页。对话框中的页是向导页 QWizardPage，向导页有自己的布局和控件，向导会为向导页分配从 0 开始的 ID 号。

  向导对话框 QWizard 是从 QDialog 类继承来的，QWizardPage 是从 QWidget 类继承来的，用 QWizard 类和 QWizardPage 类创建实例对象的方法如下所示。

QWizard(parent:QWidget=None, flags:Qt.WindowFlags=Default(Qt.WindowFlags))
QWizardPage(parent:QWidget=None)

  QWizard 类常用方法：

# 实例方法
addPage(page:QWizardPage) -> int                                                    # 添加向导页，并返回ID
setPage(id:int, page:QWizardPage) -> None                                           # 用指定ID号添加向导页
removePage(id:int) -> None                                                          # 移除指定id的向导页
currentId() -> int                                                                  # 返回当前向导页的ID
currentPage() -> QWizardPage                                                        # 返回当前向导页
hasVisitedPage(id:int) -> bool                                                      # 获取向导页是否被访问过
visitedIds() -> List[int]                                                           # 获取访问过的页的ID列表
page(id:int) -> QWizardPage                                                         # 返回指定ID的向导页
pageIds() -> List[int]                                                              # 获取向导页的ID列表setButton(which:QWizard.WizardButton, button:QAbstractButton) -> None               # 添加某种用途的按钮
button(which:QWizard.WizardButton) -> QAbstractButton                               # 获取某种用途的按钮
setButtonLayout(layout:Sequence[QWizard.WizardButton]) -> None                      # 设置按钮的布局（相对位置）
setButtonText(which:QWizard.WizardButton, text:str) -> None                         # 设置按钮的文本
buttonText(which:QWizard.WizardButton) -> str                                       # 获取按钮的文本setField(name:str, value:Any) -> None                                               # 设置字段的值
field(name:str) -> Any                                                              # 获取字段的值setOption(option:QWizard.WindowOption, on:bool=true) -> None                        # 设置向导对话框的选项
options() -> QWizard.QWizardOptions                                                 # 获取向导对话框的选项
testOption(option:QWizard.WindowOption) -> bool                                     # 测试是否设置了某个选项setPixmap(which:QWizard.WizardPixmap, pixmap:Union[QPixmap, Qimage, str]) -> None   # 在对话框的指定区域设置图片
pixmap(which:QWizard.WizardPixmap) -> QPixmap                                       # 获取对话框的图片setSideWidget(widget:QWidget) -> None                                               # 设置侧边栏setStartId(id:int) -> None                                                          # 设置初始页
startId() -> int                                                                    # 获取初始页setTitleFormat(format:Qt.TextFormat) -> None                                        # 设置标题的格式
setSubTitleFormat(format:Qt.TextFormat) -> None                                     # 设置子标题的格式setWizardStyle(style:QWizard.WizardStyle) -> None                                   # 设置向导对话框的样式
wizardStyle() -> QWizard.WizardStyle                                                # 获取向导对话框的样式cleanupPage(id:int) -> None                                                         # 清除内容，恢复默认值
initializePage(id:int) -> None                                                      # 初始化向导页
nextId() -> int                                                                     # 返回下一页的ID 
validateCurrentPage() -> bool                                                       # 验证当前页的输入是否合法# 槽方法
restart() -> None                                                                   # 回到初始页
back() -> None                                                                      # 显示上一页
next() -> None                                                                      # 显示下一页

  向导对话框的风格用 setWizardStyle(style:QWizard.WizardStyle) 方法设置，其中参数 style 是 QWizard.WizardStyle 的枚举值，可以取值如下：

QWizard.WizardStyle.ClassicStyle
QWizard.WizardStyle.ModernStyle
QWizard.WizardStyle.MacStyle
QWizard.WizardStyle.AeroStyle

  向导对话框的标题和子标题由向导页的 setTitle(title:str) 方法和 setSubTitle(subTitle:str) 方法设置，虽然由向导页设置标题和子标题，但是它们会显示在向导对话框的横幅中。标题和子标题的格式由向导对话框的 setTitleFormat(format:Qt.TextFormat) 方法和 setSubTitleFormat(format:Qt.TextFormat) 方法设置，其中参数 format 的取值是 Qt.TextFormat 枚举值，可以取值如下：

Qt.TextFormat.PlainText      # 纯文本
Qt.TextFormat.RichText       # 富文本
Qt.TextFormat.AutoText       # 由系统决定
Qt.TextFormat.MarkdownText   # Markdown文本

  向导对话框的选项由 setOption(QWizard.WizardOption,on=True) 方法设置，其中 QWizard.WizardOption 参数是枚举类型，可以取值如下：

QWizard.WizardOption.IndependentPages                   # 向导页之间是相互独立的,相互间不传递数据
QWizard.WizardOption.IgnoreSubTitles                    # 不显示子标题
QWizard.WizardOption.ExtendedWatermarkPixmap            # 将水印图片拓展到窗口边缘
QWizard.WizardOption.NoDefaultButton                    # 不将Next按钮和Finish按钮设置成默认按钮
QWizard.WizardOption.NoBackButtonOnStartPage            # 在起始页中不显示Back按钮
QWizard.WizardOption.NoBackButtonOnLastPage             # 在最后页中不显示Back按钮
QWizard.WizardOption.DisabledBackButtonOnLastPage       # 在最后页中Back按钮失效
QWizard.WizardOption.HaveNextButtonOnLastPage           # 在最后页中显示失效的Next按钮
QWizard.WizardOption.HaveFinishButtonOnEarlyPages       # 在非最后页中显示失效的Finsh按钮
QWizard.WizardOption.NoCancelButton                     # 不显示Cancel按钮
QWizard.WizardOption.CancelButtonOnLeft                 # 将Cancel按钮放到Back按钮的左边
QWizard.WizardOption.HaveHelpButton                     # 显示Help按钮
QWizard.WizardOption.HelpButtonOnRight                  # 将帮助按钮放到右边
QWizard.WizardOption.HaveCustomButton1                  # 显示用户自定义的第一个按钮
QWizard.WizardOption.HaveCustomButton2                  # 显示用户自定义的第二个按钮
QWizard.WizardOption.HaveCustomButton2                  # 显示用户自定义的第二个按钮
QWizard.WizardOption.NoCancelButtonOnLastPage           # 在最后页中不显示Cancel按钮

  向导对话框和向导页都可以用 setPixmap(which:QWizard.WizardPixmap,pixmap:QPixmap) 方法设置向导对话框中显示的图片，用向导对话框设置的图片作用于所有页，用向导页设置的图片只作用于向导页所在的页面，其中参数 which 的取值是 QWizard.WizardPixmap 的枚举值，用于设置图片放置的位置，可以取值如下：

QWizard.WizardPixmap.WatermarkPixmap
QWizard.WizardPixmap.LogoPixmap
QWizard.WizardPixmap.BannerPixmap
QWizard.WizardPixmap.BackgroundPixmap

  用 setButton(which:QWizard.WizardButton,button:QAbstractButton) 方法往对话框中添加某种用途的按钮，其中参数 which 的取值是 QWizard.WizardButton 的枚举值，用于指定按钮的用途。QWizard.WizardButton的取值如下所示。

QWizard.WizardButton.BackButton             # Back按钮
QWizard.WizardButton.NextButton             # Next按钮
QWizard.WizardButton.CommitButton           # Commit按钮
QWizard.WizardButton.FinishButton           # Finish按钮
QWizard.WizardButton.CancelButton           # Cancel按钮
QWizard.WizardButton.HelpButton             # Help按钮
QWizard.WizardButton.CustomButton1          # 用户自定义第一个按钮
QWizard.WizardButton.CustomButton2          # 用户自定义第二个按钮
QWizard.WizardButton.CustomButton3          # 用户自定义第三个按钮
QWizard.WizardButton.Stretch                # 布局中的水平伸缩器

  对话框中最多可以添加 3 个自定义的按钮，要使自定义按钮可见，还需要用 setOption() 方法把自定义按钮显示出来。通常情况下 Next 按钮和 Finish 按钮是互斥的。

  QWizard 类常用信号：

currentIdChanged(id:int)            # 当前页面id改变时发射信号，参数是新页的id
customButtonClicked(which:int)      # 单击自定义按钮时发射信号，参数是自定义按钮的索引
helpRequested()                     # 单击帮助按钮时发射信号
pageAdded(id:int)                   # 添加向导页是发射信号，参数是新页的id
pageRemoved(id:int)                 # 移除向导页是发射信号，参数是被移除页的id

  QWizardPage 类常用方法：

setButtonText(which:QWizard.WizardButton, text:str) -> None                                     # 设置某种用途按钮的文字
buttonText(which:QWizard.WizardButton) -> str                                                   # 获取指定用途的按钮的文本setCommitPage(commitPage:bool) -> None                                                          # 设置成提交页
isCommitPage() -> bool                                                                          # 获取是否是提交页
setFinalPage(finalPage:bool) -> None                                                            # 设置成最终页
isFinalPage() -> bool                                                                           # 获取是否是最终页setPixmap(which:QWizard.WizardPixmap, pixmap:QPixmap) -> None                                   # 在指定区域设置图片
pixmap(which:QWizard.WizardPixmap) -> QPixmap                                                   # 获取指定区域的图片
setTitle(title:str) -> None                                                                     # 设置标题
title() -> str                                                                                  # 获取标题
setSubTitle(subTitle:str) -> None                                                               # 设置子标题
subTitle() -> str                                                                               # 获取子标题registerField(name:str, widget:QWidget, property:str=None, changed_signal:str=None) -> None     # 创建字段
setField(name:str, value:Any) -> None                                                           # 设置字段的值
field(name:str) -> Any                                                                          # 获取字段的值validatePage() -> bool                                                                          # 验证向导页中输入的内容
wizard() -> QWizard                                                                             # 获取向导页所在的向导对话框
cleanupPage() -> None                                                                           # 清除内容，恢复默认值
initializePage() -> None                                                                        # 初始化向导页中的内容
isComplete () -> bool                                                                           # 获取是否完成输入，以便激活Next按钮或Finish按钮
validatePage() -> bool                                                                          # 验证向导页中输入的内容，若为True，则显示下一页
nextId() -> int                                                                                 # 返回下一页的ID

  用向导页的 setCommitPage(bool) 方法可以把向导页设置成提交页，提交页上用 Commit 按钮替换 Next 按钮，且不能用 Back 或 Cancel 按钮来撤销。单击 Commit 按钮后，下一页的 Back 按钮失效。用 isCommit() 方法可以获取该页是否是提交页。

  用向导页的 setFinalPage(bool) 方法可以把向导页设置成最后页，最后页上用 Finish 按钮替换 Next 按钮，此时用 nextId() 方法获取下一页的 ID 时返回 -1。

  向导对话框中的多个向导页之间的数据不能自动进行通信，要实现向导页之间的数据传递，可以将向导页上的控件属性定义成字段，并可以将控件属性与某信号关联，这样当属性值发生变化时发送信号，也可以通过字段设置或获取控件的属性值，字段对于向导对话框来说是全局性的。

  字段的定义通过 registerField(name:str,widget:QWidget,property:str=None,changedSignal:str=None) 函数来实现，其中 name 是 字段名称，widget 是 向导页上的控件，property 是 字段的属性，changedSignal 是 与字段属性相关的信号。

  定义好字段后，可以利用 setField(name:str,value:Any) 方法和 field(name:str) 方法设置和获取字段的值。用 setDefaultProperty(className:str,property:str,changedSignal:str) 方法可以设置某类控件的某个属性与某个信号相关联。

  PySide6 对大多数控件能自动将某个属性与某个信号相关联。

控件	属性	关联的信号
QAbstractButton	checked	toggled(bool)
QAbstractSlider	value	valueChange(int)
QComboBox	currentIndex	currentIndexChanged(ing)
QDateTimeEdit	dateTime	dateTimeChanged(QDatetime)
QLineEdit	text	textChanged(str)
QListWidget	currentRow	currentRowChanged(bool)
QSpinBox	value	valueChanged(int)

  当 isComplete() 函数的返回值为 True 时，会激活 Next 按钮或 Finish 按钮。可以重写该函数，用户在页面上输入信息后，当满足一定条件时改变 isComplete() 的返回值，以便激活 Next 按钮或 Finish 按钮。如果重写 isComplete() 函数，一定要确保 completeChange() 信号也能发送。

  用户单击 Next 按钮或 Finish 按钮后，需要验证页面上输入的内容是否合法，这时会调用向导对话框的 validateCurrentPage() 函数和向导页的 validatePage() 函数，通常需要重写这两个函数以便完成对输入内容的验证，如果返回 True 则显示下一页。

  单击 Next 按钮后，在显示下一页之前，会调用向导页的 initializePage() 函数。可以重写该函数，以便根据前面的向导页的内容初始化本向导页的内容。

  单击 Back 按钮后，在显示前一页之前，会调用向导页的 cleanupPage() 函数。可以重写该函数，以保证向导页能恢复默认值。

  根据 nextId() 函数的返回值，决定要显示的下一页，如果没有后续页，则返回 -1。单击 next 按钮和 back 按钮都会调用 nextId() 函数，如果重写该函数，会根据已经输入和选择的内容让 nextId() 返回相应页的 ID 号，从而控制页面显示的顺序。

  QWizardPage 类常用信号：

completeChanged()        # 当isCompleted()的返回值发生变化时发射信号

import sysfrom PySide6.QtWidgets import QApplication, QWidget
from PySide6.QtWidgets import QWizard, QWizardPage
from PySide6.QtWidgets import QFormLayout
from PySide6.QtWidgets import QLineEdit, QPlainTextEdit, QSpinBox
from PySide6.QtWidgets import QPushButton, QComboBox
from PySide6.QtWidgets import QMessageBox# 向导页1
class WizardPage_1(QWizardPage):def __init__(self, parent=None):# 调用父类的__init__()方法super().__init__(parent)# 设置主标题self.setTitle("学生成绩输入系统")# 设置子标题self.setSubTitle("基本信息")# 创建表单布局form = QFormLayout(self)# 创建单行文本框控件self.line_name = QLineEdit()self.line_name.setPlaceholderText("请输入姓名")self.line_number = QLineEdit()self.line_number.setPlaceholderText("请输入学号")# 向表单布局中添加行form.addRow("姓名: ", self.line_name)form.addRow("学号: ", self.line_number)# 定义信号与槽的连接self.line_name.textChanged.connect(self.isComplete)self.line_number.textChanged.connect(self.isComplete)self.line_name.textChanged.connect(self.completeChanged_emit)self.line_number.textChanged.connect(self.completeChanged_emit)# 创建字段self.registerField("name", self.line_name)self.registerField("number", self.line_number)# 重写isComplete()函数def isComplete(self):if self.line_name.text() != "" and self.line_number.text() != "":return Trueelse:return False# 重写isComplete()函数后,需要重新发送信号def completeChanged_emit(self):self.completeChanged.emit()# 重写数据校验的函数def validatePage(self):# 确保学号输入的数字if self.line_number.text().isdigit():return Trueelse:QMessageBox.warning(self, "警告", "输入有误,请检查输入的信息")return False# 向导页2
class WizardPage_2(QWizardPage):def __init__(self, parent=None):# 调用父类的__init__()方法super().__init__(parent)# 设置主标题self.setTitle("学生成绩输入系统")# 设置子标题self.setSubTitle("详情信息")# 创建表单布局form = QFormLayout(self)# 创建组合框控件comboBox_gender = QComboBox()comboBox_gender.addItems(["女", "男"])form.addRow("性别: ", comboBox_gender)# 创建整数选择控件spinBox_age = QSpinBox()spinBox_age.setRange(0, 300)form.addRow("年龄: ", spinBox_age)# 创建字段self.registerField("gender", comboBox_gender)self.registerField("age", spinBox_age)# 向导页3
class WizardPage_3(QWizardPage):def __init__(self, parent=None):# 调用父类的__init__()方法super().__init__(parent)# 设置主标题self.setTitle("学生成绩输入系统")# 设置子标题self.setSubTitle("考试成绩")# 创建表单布局form = QFormLayout(self)# 创建小数选择控件spinBox_chinese = QSpinBox()spinBox_chinese.setRange(0, 150)spinBox_math = QSpinBox()spinBox_math.setRange(0, 150)spinBox_english = QSpinBox()spinBox_english.setRange(0, 150)form.addRow("语文: ", spinBox_chinese)form.addRow("数学: ", spinBox_math)form.addRow("英语: ", spinBox_english)# 创建字段self.registerField("chinese", spinBox_chinese)self.registerField("math", spinBox_math)self.registerField("english", spinBox_english)# 向导对话框
class Wizard(QWizard):def __init__(self, parnent=None):# 调用父类的__init__()方法super().__init__(parnent)# 设置向导对话框的风格self.setWizardStyle(QWizard.WizardStyle.ModernStyle)# 添加向导页self.addPage(WizardPage_1(self))self.addPage(WizardPage_2(self))self.addPage(WizardPage_3(self))# 创建按钮控件self.button_back = QPushButton("上一步")self.button_next = QPushButton("下一步")self.button_cancel = QPushButton("取消")self.button_finish = QPushButton("完成")# 向导对话框中添加某种用途的按钮self.setButton(QWizard.WizardButton.BackButton, self.button_back)self.setButton(QWizard.WizardButton.NextButton, self.button_next)self.setButton(QWizard.WizardButton.CancelButton, self.button_cancel)self.setButton(QWizard.WizardButton.FinishButton, self.button_finish)# 设置向导对话框中按钮的布局self.setButtonLayout([self.WizardButton.Stretch,self.WizardButton.CancelButton,self.WizardButton.BackButton, self.WizardButton.NextButton,self.WizardButton.FinishButton])class MyWidget(QWidget):def __init__(self):# 1.调用父类Qwidget类的__init__()方法super().__init__()# 2.调用setupUi()方法初始化页面self.setup_ui()def setup_ui(self):# 1.设置窗口对象大小self.resize(700, 500)# 2.创建向导对话框self.wizard = Wizard()# 3.创建按钮控件,点击弹出向导对话框button_enter = QPushButton("点击进入学生成绩管理系统", self)button_enter.clicked.connect(self.enter_wizard)# 创建多行文本框控件,用来显示信息self.plainText = QPlainTextEdit(self)self.plainText.setGeometry(0, 50, 500, 300)self.plainText.setReadOnly(True)# 定义信号与槽的连接self.wizard.button_finish.clicked.connect(self.complete)def enter_wizard(self):# 设置初始页self.wizard.setStartId(0)# 重新启动self.wizard.restart()# 打开对话框self.wizard.open()def complete(self):template = "姓名: {}, 学号: {}, 性别: {}, 年龄: {}, 语文: {}, 数学: {}, 英语: {}\r\n"gender = ""if str(self.wizard.field("gender")) == "1":gender = "男"elif str(self.wizard.field("gender")) == "0":gender = "女"string = template.format(self.wizard.field("name"), self.wizard.field("number"), gender,self.wizard.field("age"),self.wizard.field("chinese"), self.wizard.field("math"), self.wizard.field("english"))print(string)self.plainText.appendPlainText(string)if __name__ == "__main__":# 1.创建一个QApplication类的实例app = QApplication(sys.argv)# 2.创建一个窗口window = MyWidget()# 3.展示窗口window.show()# 4.进入程序的主循环并通过exit()函数确保主循环安全结束sys.exit(app.exec())