重学Qt——对话框和多窗口程序设计

我在人间贩卖青春2026-05-22 8:29

对话框和多窗口程序设计

窗口应用程序设计

多窗口应用程序设计概述

  • 重要性：在一个复杂的应用程序中，多窗口设计和调用是必不可少的功能。主界面窗口通常需要调用多个其他窗口或对话框，并进行数据交换。

使用Qt提供的标准对话框

  • Qt框架提供了丰富的标准对话框，如消息框、文件对话框等，可以直接在应用程序中使用。

设计和调用自定义对话框

  • 根据应用程序的特定需求，可能需要设计自定义的对话框。
  • 设计和创建自定义对话框的方法，包括界面设计、功能实现和调用等。

设计多窗口程序，类似于多页浏览器

  • 这种类型的多窗口程序允许用户在多个窗口之间切换，类似于网页浏览器的多标签页功能。
  • 需要设计主界面窗口和多个子窗口，实现它们之间的导航和数据交换。

设计标准MDI（多文档界面）应用程序

  • MDI应用程序允许多个窗口在单一主窗口内打开，每个窗口都有自己的视图和控件。
  • 需要设计MDI主窗口和子窗口，实现子窗口的管理和数据的共享。

标准对话框

Qt为应用程序设计提供的标准对话框

Qt框架提供了一系列的标准对话框，这些对话框为开发者提供了方便、快捷的用户界面交互方式。这些标准对话框包括：打开文件对话框、选择颜色对话框、信息提示和确认选择对话框、标准输入对话框等。

标准对话框类的主要静态函数

这些标准对话框类提供了一些静态函数，通过这些静态函数，可以直接使用标准对话框的主要功能。这些静态函数是调用对话框的关键。

各标准对话框类及其主要静态函数的功能

  • 打开文件对话框：提供文件选择功能，允许用户选择文件或文件夹。
  • 选择颜色对话框：提供一个颜色选择器，允许用户从颜色表中选取颜色。
  • 信息提示和确认选择对话框：用于显示信息并获取用户的确认或选择。例如，提示框可以显示消息并请求用户进行确认或取消操作。
  • 标准输入对话框：允许用户输入数据，这些数据可以直接返回到程序中。例如，输入字符串、数字等。

注意：具体的函数参数和返回值类型可能因Qt版本和具体实现有所不同，需要参考Qt官方文档以获取准确信息。

使用方式

在设计程序时，开发者可以直接调用这些标准对话框的静态函数来使用这些对话框，无需自己编写界面代码，可以大大简化了开发过程。这些标准对话框的使用也提高了应用程序的用户体验。

QT标准对话框类型：

对话框类名称 描述
QFileDialog 用于打开和保存文件的对话框。允许用户选择文件或目录，并提供了自定义文件过滤器的功能。常用于文件浏览器的交互界面中。
QColorDialog 用于选择颜色的对话框。提供了一个颜色选择器，用户可以在其中选择颜色。常用于需要用户选择特定颜色的场景，如设置文本颜色或背景色等。
QFontDialog 用于选择字体的对话框。提供了一个字体选择器，用户可以在其中选择字体样式、大小等属性。常用于字体编辑或文本显示设置等场景。
QProgressDialog 用于显示任务进度的对话框。提供了一个进度条，可以显示任务的进度信息。常用于长时间运行的任务，为用户提供进度反馈。
QInputDialog 用于获取用户输入的简单对话框。通常用于请求用户输入一个字符串值或其他数据类型，比如用户名、密码等。
QMessageBox 用于显示消息和警告的对话框。可以显示文本消息、警告图标以及自定义按钮等。常用于显示应用程序中的信息提示、错误警告等。
QPrintDialog 用于打印设置的对话框。提供了一个界面，用户可以在其中选择打印机、设置页面范围等打印选项。常用于打印文档的场景。
QPrintPreviewDialog 用于预览打印效果的对话框。用户可以在这个对话框中预览文档的打印效果，包括页面布局、格式等。常用于在打印前给用户提供一个预览和确认的机会。

QFileDialog

QFileDialog 是 Qt 框架中的一个类，用于提供标准的文件选择对话框。它允许用户选择文件或目录，支持打开文件、保存文件以及选择多个文件等功能。

功能特点

  • 文件选择：用户可以选择单个或多个文件，也可以选择目录。
  • 过滤器：支持文件类型过滤器，用户可以指定看到的文件类型（如图片、文本等）。
  • 默认路径：可以设置对话框打开时的默认目录。
  • 自定义选项：提供可自定义的按钮和选项，以适应特定需求。

示例：使用 QFileDialog 实现文件选择功能

cpp 复制代码 
#include <QApplication>
#include <QFileDialog>
#include <QPushButton>
#include <QWidget>
#include <QVBoxLayout>

class FileDialogExample : public QWidget {
public:
    FileDialogExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        QPushButton *button = new QPushButton("打开文件");
        layout->addWidget(button);
        
        connect(button, &QPushButton::clicked, this, &FileDialogExample::openFileDialog);
    }

private slots:
    void openFileDialog() {
        QString fileName = QFileDialog::getOpenFileName(this, "选择文件", "", "Images (*.jpg *.jpeg *.png);;All Files (*)");
        
        if (!fileName.isEmpty()) {
            // 这里可以添加对选择文件的处理逻辑
            qDebug() << "选择的文件:" << fileName;
        }
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    FileDialogExample window;
    window.setWindowTitle("QFileDialog 示例");
    window.resize(400, 300);
    window.show();
    
    return app.exec();
}

代码解析

  1. 包含头文件：示例中需包含必要的 Qt 头文件。
  2. 创建主窗口：继承 QWidget 创建简单的窗口。
  3. 创建按钮：添加一个按钮，点击时弹出文件对话框。
  4. 文件对话框的调用：使用 QFileDialog::getOpenFileName() 方法打开文件对话框。参数包括父窗口、标题、默认目录及文件类型过滤器。
  5. 处理选择结果：如果用户选择了文件，可以在控制台输出选择的文件路径。

QColorDialog

QColorDialog 是 Qt 框架中的一个类，用于提供颜色选择对话框。它允许用户从颜色表中选择颜色，支持多种颜色选择方式，能够方便地集成到应用程序中。

功能特点

  • 颜色选择：用户可以选择任意颜色，支持 RGB 和 HSL 色彩模型。
  • 最近使用：可以展示用户最近使用的颜色。
  • 自定义颜色：支持添加用户定义的颜色。
  • 集成简便：易于在窗口中调用，且界面友好。

示例：如何使用 QColorDialog 进行颜色选择

cpp 复制代码 
#include <QApplication>
#include <QColorDialog>
#include <QPushButton>
#include <QVBoxLayout>
#include <QWidget>
#include <QLabel>

class ColorDialogExample : public QWidget {
public:
    ColorDialogExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        QPushButton *button = new QPushButton("选择颜色");
        layout->addWidget(button);
        
        colorLabel = new QLabel("选择的颜色将显示在这里");
        layout->addWidget(colorLabel);
        
        connect(button, &QPushButton::clicked, this, &ColorDialogExample::openColorDialog);
    }

private slots:
    void openColorDialog() {
        QColor color = QColorDialog::getColor(Qt::white, this, "选择颜色");
        
        if (color.isValid()) {
            colorLabel->setText("选择的颜色: " + color.name());
            setStyleSheet("QLabel { background-color: " + color.name() + "; }");
        }
    }

private:
    QLabel *colorLabel;
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    ColorDialogExample window;
    window.setWindowTitle("QColorDialog 示例");
    window.resize(300, 200);
    window.show();
    
    return app.exec();
}

代码解析

  1. 包含头文件：示例中需包含必要的 Qt 头文件。
  2. 创建主窗口：继承 QWidget 创建一个简单的窗口。
  3. 创建按钮：添加一个按钮，点击时弹出颜色选择对话框。
  4. 打开颜色对话框：使用 QColorDialog::getColor() 方法打开颜色对话框。参数包括默认颜色、父窗口和对话框标题。
  5. 处理选择结果：如果用户选择了颜色，更新标签文本并设置标签背景颜色。

运行结果：

QFontDialog

QFontDialog 是 Qt 框架中的一个类，用于提供字体选择对话框。用户可以通过该对话框选择字体，包括字体名称、样式、大小等。这个组件使得在应用程序中实现字体选择变得简单直观。

功能特点

  • 字体选择：用户可以选择字体的名称、大小、样式和粗细。
  • 预览功能：展示所选字体效果的预览区域。
  • 最近使用的字体：可以显示用户最近使用的字体。
  • 自定义选项：支持自定义选项，以适应特定需求。

示例：如何使用 QFontDialog 进行字体选择

cpp 复制代码 
#include <QApplication>
#include <QFontDialog>
#include <QPushButton>
#include <QVBoxLayout>
#include <QWidget>
#include <QLabel>

class FontDialogExample : public QWidget {
public:
    FontDialogExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        QPushButton *button = new QPushButton("选择字体");
        layout->addWidget(button);
        
        fontLabel = new QLabel("选择的字体将显示在这里");
        layout->addWidget(fontLabel);
        
        connect(button, &QPushButton::clicked, this, &FontDialogExample::openFontDialog);
    }

private slots:
    void openFontDialog() {
        bool ok;
        QFont font = QFontDialog::getFont(&ok, fontLabel->font(), this, "选择字体");
        
        if (ok) {
            fontLabel->setFont(font);
            fontLabel->setText("选择的字体: " + font.family());
        }
    }

private:
    QLabel *fontLabel;
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    FontDialogExample window;
    window.setWindowTitle("QFontDialog 示例");
    window.resize(300, 200);
    window.show();
    
    return app.exec();
}

代码解析

  1. 包含头文件：示例中需要包含必要的 Qt 头文件。
  2. 创建主窗口：继承 QWidget 创建一个简单的窗口。
  3. 创建按钮：添加一个按钮，点击时弹出字体选择对话框。
  4. 打开字体对话框：使用 QFontDialog::getFont() 方法打开字体对话框。参数包括一个指向布尔值的指针（表明用户是否确认选择）、默认字体、父窗口和对话框标题。
  5. 处理选择结果：如果用户选择了字体，更新标签的字体和文本，显示选择的字体名称。

运行结果：

QProgressDialog

QProgressDialog 是 Qt 框架中的一个类，用于显示一个进度对话框，通常在执行耗时操作时使用。它向用户提供操作的进度反馈，可以是确定的进度（范围从0到100）或不确定的进度（使用旋转指示器）。

功能特点

  • 进度指示：显示当前操作的进度，支持设置范围和增量。
  • 可取消操作：可以添加取消按钮，以允许用户中止长时间运行的操作。
  • 信息提示：可以显示与进度相关的信息。

示例：如何使用 QProgressDialog 来显示进度。

cpp 复制代码 
#include <QApplication>
#include <QProgressDialog>
#include <QPushButton>
#include <QVBoxLayout>
#include <QWidget>
#include <QThread>

class Task : public QThread {
    Q_OBJECT
public:
    void run() override {
        for (int i = 0; i <= 100; ++i) {
            QThread::sleep(50); // 模拟耗时操作
            emit progressUpdated(i);
        }
    }

signals:
    void progressUpdated(int value);
};

class ProgressDialogExample : public QWidget {
    Q_OBJECT
public:
    ProgressDialogExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        QPushButton *button = new QPushButton("开始任务");
        layout->addWidget(button);
        
        connect(button, &QPushButton::clicked, this, &ProgressDialogExample::startTask);
    }

private slots:
    void startTask() {
        QProgressDialog progressDialog("任务进行中...", "取消", 0, 100, this);
        progressDialog.setWindowModality(Qt::WindowModal);
        
        Task *task = new Task();
        
        connect(task, &Task::progressUpdated, &progressDialog, &QProgressDialog::setValue);
        connect(task, &Task::progressUpdated, this, &ProgressDialogExample::checkCancel);
        connect(&progressDialog, &QProgressDialog::canceled, task, &Task::terminate);
        
        task->start();
        
        progressDialog.exec();
    }

    void checkCancel(int value) {
        if (value >= 100) {
            qApp->exit();
        }
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    ProgressDialogExample window;
    window.setWindowTitle("QProgressDialog 示例");
    window.resize(300, 150);
    window.show();
    
    return app.exec();
}

#include "main.moc"

代码解析

  1. 包含头文件：示例中需要包含必要的 Qt 头文件。
  2. 创建任务类：定义一个 Task 类继承自 QThread ，在 run() 方法中模拟耗时操作。
  3. 创建主窗口：继承 QWidget 创建一个简单的窗口并添加按钮。
  4. 打开进度对话框：在 startTask() 槽中创建 QProgressDialog ，设置范围为0到100，并添加取消按钮。
  5. 连接信号与槽：
    • 当任务进度更新时，发送信号更新对话框进度。
    • 如果用户点击取消按钮，终止任务。
  6. 执行任务：启动任务线程并显示进度对话框。

运行结果：

QInputDialog

QInputDialog 是 Qt 框架中的一个类，用于提供一个简单的对话框，使得用户能够输入文本、选择数值或从列表中选择项。这个对话框非常适合用于快速获取用户的输入。

常用属性：

属性 描述
textValue() 获取用户输入的文本值。
textLabel() 获取或设置输入框的标签文本。
echoMode() 获取或设置输入框的输入模式（例如，是否显示输入的文本）。
labelTextVisible() 获取标签文本是否可见。
setInputMode() 设置输入对话框的输入模式（如文本输入、整数输入等）。
setResult() 设置对话框的结果值，通常在用户点击某个按钮后使用。
setResultValue() 设置输入框的结果值，可以是任何类型的数据（如字符串、整数等）。
setValueValidator() 设置输入框的值验证器，以验证用户输入的有效性。
options() 获取或设置对话框的选项（如是否可调整大小等）。

常用方法：

方法 描述
setLabelText() 设置对话框的标签文本。
setLabelPixmap() 设置对话框的标签图像。
setTextValue() 设置输入框的初始文本值。
setTextValue(QString) 设置输入框的文本值。
setTextLabels() 设置输入框的标签和提示文本。
getValue() 获取输入框中的文本值。
setInputMode() 设置输入对话框的模式（如文本、整数等）。
setValueRange() 设置输入值的范围（适用于某些输入模式）。
setValidator() 设置输入值的验证器，确保输入满足特定条件。
setWindowTitle() 设置对话框窗口的标题。
setLabelWidget() 设置标签部件（如标签或自定义布局）。
show() 显示对话框并等待用户响应。返回用户输入的文本值或关闭对话框时的结果。

示例：如何使用 QInputDialog 获取用户输入。

cpp 复制代码 
#include <QApplication>
#include <QInputDialog>
#include <QPushButton>
#include <QVBoxLayout>
#include <QWidget>
#include <QLabel>

class InputDialogExample : public QWidget {
public:
    InputDialogExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        QPushButton *textButton = new QPushButton("输入文本");
        QPushButton *intButton = new QPushButton("输入整数");
        QPushButton *doubleButton = new QPushButton("输入浮点数");
        QPushButton *itemButton = new QPushButton("选择项");
        
        layout->addWidget(textButton);
        layout->addWidget(intButton);
        layout->addWidget(doubleButton);
        layout->addWidget(itemButton);
        
        connect(textButton, &QPushButton::clicked, this, &InputDialogExample::showTextInputDialog);
        connect(intButton, &QPushButton::clicked, this, &InputDialogExample::showIntInputDialog);
        connect(doubleButton, &QPushButton::clicked, this, &InputDialogExample::showDoubleInputDialog);
        connect(itemButton, &QPushButton::clicked, this, &InputDialogExample::showItemDialog);
        
        resultLabel = new QLabel("结果将显示在这里");
        layout->addWidget(resultLabel);
    }

private slots:
    void showTextInputDialog() {
        bool ok;
        QString text = QInputDialog::getText(this, "输入文本", "请输入文本:", QLineEdit::Normal, "", &ok);
        if (ok && !text.isEmpty()) {
            resultLabel->setText("输入的文本: " + text);
        }
    }

    void showIntInputDialog() {
        bool ok;
        int value = QInputDialog::getInt(this, "输入整数", "请输入整数:", 0, -100, 100, 1, &ok);
        if (ok) {
            resultLabel->setText("输入的整数: " + QString::number(value));
        }
    }

    void showDoubleInputDialog() {
        bool ok;
        double value = QInputDialog::getDouble(this, "输入浮点数", "请输入浮点数:", 0.0, -100.0, 100.0, 1, &ok);
        if (ok) {
            resultLabel->setText("输入的浮点数: " + QString::number(value));
        }
    }

    void showItemDialog() {
        QStringList items;
        items << "选项1" << "选项2" << "选项3";
        bool ok;
        QString item = QInputDialog::getItem(this, "选择项", "请选择一个选项:", items, 0, false, &ok);
        if (ok && !item.isEmpty()) {
            resultLabel->setText("选择的项: " + item);
        }
    }

private:
    QLabel *resultLabel;
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    InputDialogExample window;
    window.setWindowTitle("QInputDialog 示例");
    window.resize(300, 200);
    window.show();
    
    return app.exec();
}

代码解析

  1. 包含头文件：示例中需要包含必要的 Qt 头文件。
  2. 创建主窗口：继承 QWidget 创建一个简单的窗口，并添加多个按钮用于不同类型的输入。
  3. 打开输入对话框：
    • 使用 QInputDialog::getText() 获取文本输入。
    • 使用 QInputDialog::getInt() 获取整数输入，并设置范围。
    • 使用 QInputDialog::getDouble() 获取浮点数输入，并设置范围和步长。
    • 使用 QInputDialog::getItem() 让用户从列表中选择一项。
  4. 处理输入结果：根据用户的输入更新标签内容，以实时显示用户输入的结果。

QMessageBox

QMessageBox 是 Qt 框架中的一个类，用于显示消息对话框，提示用户信息、警告、错误或询问用户的操作选择。

常用属性：

属性 描述
setText 设置消息框的主文本内容。
setInformativeText 设置附加信息文本，用于提供更多上下文。
setDetailedText 设置详细信息文本，通常用于提供额外的技术信息。
setIcon 设置消息框的图标类型（例如信息、警告、错误等）。
setWindowTitle 设置消息框的标题。
setStandardButtons 设置标准按钮（例如 OK、Cancel、Yes、No 等）。
setDefaultButton 设置默认按钮，用户按下 Enter 键时将选择的按钮。
exec() 显示消息框并阻塞直到用户做出选择。
information 显示信息类型的消息框（静态方法）。
warning 显示警告类型的消息框（静态方法）。
critical 显示错误类型的消息框（静态方法）。
question 显示询问类型的消息框（静态方法）。

示例：如何使用 QMessageBox 。

cpp 复制代码 
#include <QApplication>
#include <QMessageBox>
#include <QPushButton>
#include <QVBoxLayout>
#include <QWidget>

class MessageBoxExample : public QWidget {
public:
    MessageBoxExample() {
        QVBoxLayout *layout = new QVBoxLayout(this);
        
        QPushButton *infoButton = new QPushButton("信息提示");
        QPushButton *warningButton = new QPushButton("警告提示");
        QPushButton *errorButton = new QPushButton("错误提示");
        QPushButton *questionButton = new QPushButton("询问用户");
        
        layout->addWidget(infoButton);
        layout->addWidget(warningButton);
        layout->addWidget(errorButton);
        layout->addWidget(questionButton);
        
        connect(infoButton, &QPushButton::clicked, this, &MessageBoxExample::showInfoMessage);
        connect(warningButton, &QPushButton::clicked, this, &MessageBoxExample::showWarningMessage);
        connect(errorButton, &QPushButton::clicked, this, &MessageBoxExample::showErrorMessage);
        connect(questionButton, &QPushButton::clicked, this, &MessageBoxExample::showQuestionMessage);
    }

private slots:
    void showInfoMessage() {
        QMessageBox::information(this, "信息", "这是一个信息提示框。");
    }

    void showWarningMessage() {
        QMessageBox::warning(this, "警告", "这是一个警告提示框。请注意。");
    }

    void showErrorMessage() {
        QMessageBox::critical(this, "错误", "这是一个错误提示框。发生了错误！");
    }

    void showQuestionMessage() {
        QMessageBox::StandardButton reply;
        reply = QMessageBox::question(this, "询问", "你确定要继续吗？", 
                                       QMessageBox::Yes | QMessageBox::No);
        if (reply == QMessageBox::Yes) {
            QMessageBox::information(this, "提示", "你选择了'是'");
        } else {
            QMessageBox::information(this, "提示", "你选择了'否'");
        }
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    MessageBoxExample window;
    window.setWindowTitle("QMessageBox 示例");
    window.resize(300, 200);
    window.show();
    
    return app.exec();
}

代码解析

  1. 包含头文件：包含必要的 Qt 头文件。
  2. 创建主窗口：继承 QWidget 创建一个简单的窗口，并添加多个按钮，用于不同类型的消息框。
  3. 显示消息框：
    • 使用 QMessageBox::information() 显示信息提示。
    • 使用 QMessageBox::warning() 显示警告提示。
    • 使用 QMessageBox::critical() 显示错误提示。
    • 使用 QMessageBox::question() 提问用户，获取"是"或"否"的选择。
  4. 处理用户响应：根据用户在询问框中的选择更新消息。

运行结果：

通用的QMessageBox消息框

Qt 提供了 6 种通用的 QMessageBox 消息对话框，通过调用 QMessageBox 类中的 6 个静态成员方法，可以直接在项目中使用它们。

1、information消息对话框

information 对话框常用于给用户提示一些关键的信息

在项目中使用 information 消息对话框，直接调用 QMessageBox 类中的 information() 静态成员方法即可，该方法的语法格式如下：

plain 复制代码 
StandardButton QMessageBox::information(QWidget *parent,
                                        const QString &title,
                                        const QString &text,
                                        StandardButtons buttons = Ok,
                                        StandardButton defaultButton = NoButton)

各个参数的含义是：

  • parent：指定消息对话框的父窗口，消息提示框会作为一个独立的窗口显示在父窗口的前面。消息提示框从弹出到关闭的整个过程中，用户无法操作父窗口，更不能删除父窗口；
  • title：指定消息对话框的标题，即图 2 中的 Titile；
  • text：指定消息对话框的具体内容，即图 2 中的 text；
  • buttons：指定消息对话框中包含的按钮。默认情况下，消息对话框只包含一个按钮，即图 2 中显示的 "OK" 按钮。根据需要，我们可以用|按位或运算符在消息对话框中设置多个按钮，例如 QMessageBox::Ok|QMessageBox::Cancel；
  • defaultButton：指定 Enter 回车键对应的按钮，用户按下回车键时就等同于按下此按钮。注意，defaultButton 参数的值必须是 buttons 中包含的按钮，当然也可以不手动指定，QMessageBox 会自动从 buttons 中选择合适的按钮作为 defaultButton 的值。

information() 函数会返回用户按下的按钮。StandardButton 是 QMessageBox 类中定义的枚举类型，每个枚举值代表一种按钮。

StandardButton 类型中的值有很多：

枚举值 含 义
QMessageBox::Ok 标有 "OK" 字样的按钮，通常用来表示用户接受或同意提示框中显示的信息。
QMessageBox::Open 标有 "Open" 字样的按钮。
QMessageBox::Save 标有 "Save" 字样的按钮。
QMessageBox::Cancel 标有 "Cancel" 字样的按钮。点击此按钮，通常表示用户拒绝接受提示框中显示的信息。
QMessageBox::Close 标有 "Close" 字样的按钮。
QMessageBox::Discard 标有 "Discard" 或者 "Don't Save" 字样的按钮，取决于运行平台。
QMessageBox::Apply 标有 "Apply" 字样的按钮。
QMessageBox::Reset 标有 "Reset" 字样的按钮。
QMessageBox::Yes 标有 "Yes" 字样的按钮。
QMessageBox::No 标有 "No" 字样的按钮。

例如，使用 information() 函数实现图 2 所示的对话框，实现代码为：

plain 复制代码 
QMessageBox::StandardButton result = QMessageBox::information(&widget, "Title","text");

其中，widget 是我们创建好的 QWidget 窗口，创建好的 information 对话框会显示在 widget 窗口的前面。通过用 result 接收 information() 函数的返回值，我们可以得知用户选择的是哪个按钮。

2、critical消息对话框

critical 消息对话框常用于给用户提示"操作错误"或"运行失败"的信息，它的外观如下图所示：

项目中使用 critical 消息对话框，直接调用 QMessageBox 类提供的 critical() 静态成员方法即可，该方法的语法格式为：

plain 复制代码 
StandardButton QMessageBox::critical(QWidget *parent,
                                     const QString &title,
                                     const QString &text,
                                     StandardButtons buttons = Ok,
                                     StandardButton defaultButton = NoButton)

各个参数的含义以及返回值的含义，都与 information() 函数相同，这里不再重复赘述。

例如，使用 critical() 函数实现图 3 所示的对话框，实现代码为：

plain 复制代码 
QMessageBox::StandardButton result=QMessageBox::critical(&widget, "Title","text");

其中，widget 是我们创建好的 QWidget 窗口，创建好的 critical 对话框会显示在 widget 窗口的前面。

3、question消息对话框

question 对话框常用于向用户提出问题并接收用户的答案，它的外观如下图所示：

项目中使用 question 对话框，可以直接调用 QMessageBox 类的 question() 静态成员方法，该方法的语法格式为：

plain 复制代码 
StandardButton QMessageBox::question(QWidget *parent,
                                     const QString &title,
                                     const QString &text,
                                     StandardButtons buttons = StandardButtons( Yes | No ),
                                     StandardButton defaultButton = NoButton)

各个参数的含义以及返回值的含义，都与 information() 函数相同。

例如，使用 question() 函数实现图 4 所示的对话框，实现代码为：

plain 复制代码 
QMessageBox::StandardButton result=QMessageBox::question(&widget, "Title","text");

其中，widget 是我们创建好的 QWidget 窗口，创建好的 question 对话框会显示在 widget 窗口的前面。

4、warning消息对话框

warining 对话框常用于向用户显示一些警告信息，它的外观如下图所示：

项目中使用 warning 对话框，可以直接调用 QMessageBox 类的 warning() 静态成员方法，该方法的语法格式为：

plain 复制代码 
StandardButton QMessageBox::warning(QWidget *parent,
                                    const QString &title,
                                    const QString &text,
                                    StandardButtons buttons = Ok,
                                    StandardButton defaultButton = NoButton)

各个参数的含义以及返回值的含义，都与 information() 函数相同。

例如，使用 warning() 函数实现图 5 所示的对话框，实现代码为：

plain 复制代码 
QMessageBox::StandardButton result=QMessageBox::warning(&widget, "Title","text");

其中，widget 是我们创建好的 QWidget 窗口，创建好的 warning 对话框会显示在 widget 窗口的前面。

5、about和aboutQt对话框

about 对话框常常作为介绍某个产品或某项功能的临时窗口，它的外观如下图所示：

注意，about 对话框没有固定的图标，它显示的图标可能来自父窗口、包含父窗口的顶层窗口等，也可能使用和 information 对话框相同的图标。

项目中使用 about 对话框，直接调用 QMessageBox 类提供的 about() 静态成员方法即可，该方法的语法格式如下：

plain 复制代码 
void QMessageBox::about(QWidget *parent, const QString &title, const QString &text)

各个参数的含义和与 information() 函数相同。和前面的几种对话框不同，about对话框中只包含一个默认的 Ok 按钮，且 about() 函数没有返回值。

aboutQt 可以看做是 about 对话框的一个具体实例，它只能显示 Qt 的介绍信息。

项目中使用 aboutQt 对话框，直接调用 QMessageBox 类提供的 aboutQt() 静态成员方法即可，该函数的语法格式如下：

plain 复制代码 
void QMessageBox::aboutQt(QWidget *parent, const QString &title = QString())

只能设置 aboutQt 对话框的 parent 父窗口和 title 标题，不能自定义它的内容。所以在实际场景中，aboutQt() 对话框很少使用。

设计自定义对话框

在设计一个应用程序的时候，有时为了实现一些特定的功能，我们需要设计自定义对话框。自定义对话框一般从QDialog类继承，而且可以使用Qt Designer可视化设计对话框界面。

对话框的使用一般包括创建对话框、传递数据给对话框、显示对话框获取输入、判断对话框的返回类型、获取对话框输入数据等步骤。本节就介绍自定义对话框的设计和使用方法。

QDialog

主要属性：

  • modal ：表示对话框的显示方式，true为模态对话框，false为非模态对话框。
  • sizeGripEnabled ：表示对话框右下角是否显示调整窗口大小的标记，一般设置为false。

对话框的显示

  • 显示方式：
    • 使用 show() 函数，根据 modal 属性的值，以模态或非模态方式显示对话框。主要用于非模态对话框，可以与主窗口交互。
    • 使用 exec() 函数，以模态方式显示对话框，并返回操作结果。可获取如"接受"或"取消"等对话框操作结果。
    • 使用 open() 函数，以模态方式显示对话框但不获取操作结果。
  • 返回值： exec() 函数有返回值，通常使用 QDialog::DialogCode 的枚举值表示，如 Accepted 和 Rejected 。

对话框的返回值处理

  • QDialog定义了3个公有槽，用于关闭对话框并设置 exec() 的返回值作为操作结果。

QDialog的信号

QDialog类定义了3个信号：

  • accepted() ：当用户通过点击"确定"按钮或调用 accept() 方法时，发出此信号。
  • rejected() ：当用户通过点击"取消"按钮或调用 reject() 方法时，发出此信号。
  • finished(int result) ：当对话框关闭时发出此信号， result 参数表示对话框的结果（如 Accepted 或 Rejected ）。

示例：如何使用 QDialog 及其信号。

cpp 复制代码 
#include <QApplication>
#include <QDialog>
#include <QVBoxLayout>
#include <QPushButton>
#include <QLabel>

class MyDialog : public QDialog {
    Q_OBJECT

public:
    MyDialog() {
        setWindowTitle("Dialog Example");

        QVBoxLayout *layout = new QVBoxLayout(this);

        label = new QLabel("Dialog is open", this);
        layout->addWidget(label);

        QPushButton *acceptButton = new QPushButton("OK", this);
        QPushButton *rejectButton = new QPushButton("Cancel", this);
        
        layout->addWidget(acceptButton);
        layout->addWidget(rejectButton);

        // 连接信号到槽
        connect(acceptButton, &QPushButton::clicked, this, &MyDialog::accept);
        connect(rejectButton, &QPushButton::clicked, this, &MyDialog::reject);
        connect(this, &MyDialog::finished, this, &MyDialog::onDialogFinished);
    }

private slots:
    void onDialogFinished(int result) {
        if (result == QDialog::Accepted) {
            label->setText("Dialog accepted");
        } else if (result == QDialog::Rejected) {
            label->setText("Dialog rejected");
        }
    }

private:
    QLabel *label;
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    MyDialog dialog;
    dialog.exec();

    return app.exec();
}

#include "main.moc"

代码解析

  1. 创建对话框：继承自 QDialog 的 MyDialog 类。
  2. 构造函数：
    • 设置对话框标题。
    • 创建并配置布局，添加标签和按钮。
    • 连接按钮点击信号到对话框的 accept() 和 reject() 方法。
    • 连接 finished(int result) 信号到自定义槽 onDialogFinished(int result) 。
  3. 槽函数：
    • onDialogFinished 根据传入的 result 参数更新标签内容，显示对话框是被接受还是拒绝。
  4. 主函数：
    • 创建 QApplication 和 MyDialog 实例，并以模态方式显示对话框。

运行结果：

对话框的模态与非模态

特性 模态对话框 非模态对话框
交互方式 阻止与其他窗口交互 允许与其他窗口同时交互
创建方法 使用 exec() 使用 show()
用户体验 用户必须处理对话框后才能继续 用户可以自由切换不同窗口
用途 输入确认、重要提示等需强制处理 设置面板、辅助窗口等可并行操作
关闭行为 关闭后返回控制到调用者 可以随时关闭，控制会继续存在
抑制背景窗口 对话框打开时，其他窗口不可操作 对话框打开时，其他窗口仍可操作
模态对话框

示例：使用 QDialog::exec() 方法创建模态对话框。

cpp 复制代码 
#include <QApplication>
#include <QDialog>
#include <QPushButton>
#include <QVBoxLayout>
#include <QLabel>

class ModalDialog : public QDialog {
public:
    ModalDialog(QWidget *parent = nullptr) : QDialog(parent) {
        QVBoxLayout *layout = new QVBoxLayout(this);
        QLabel *label = new QLabel("这是模态对话框", this);
        QPushButton *button = new QPushButton("关闭", this);
        
        connect(button, &QPushButton::clicked, this, &ModalDialog::accept);
        
        layout->addWidget(label);
        layout->addWidget(button);
        setLayout(layout);
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    QPushButton button("打开模态对话框");
    ModalDialog dialog;
    
    QObject::connect(&button, &QPushButton::clicked, [&dialog]() {
        dialog.exec(); // 以模态方式打开对话框
    });
    
    button.show();
    return app.exec();
}

运行结果：

非模态对话框

示例：使用 QDialog::show() 方法创建非模态对话框。

cpp 复制代码 
#include <QApplication>
#include <QDialog>
#include <QPushButton>
#include <QVBoxLayout>
#include <QLabel>

class NonModalDialog : public QDialog {
public:
    NonModalDialog(QWidget *parent = nullptr) : QDialog(parent) {
        QVBoxLayout *layout = new QVBoxLayout(this);
        QLabel *label = new QLabel("这是非模态对话框", this);
        QPushButton *button = new QPushButton("关闭", this);
        
        connect(button, &QPushButton::clicked, this, &NonModalDialog::accept);
        
        layout->addWidget(label);
        layout->addWidget(button);
        setLayout(layout);
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    QPushButton button("打开非模态对话框");
    NonModalDialog *dialog = nullptr;

    QObject::connect(&button, &QPushButton::clicked, [&]() {
        if (!dialog) {
            dialog = new NonModalDialog();
            dialog->show(); // 以非模态方式打开对话框
        }
    });
    
    button.show();
    return app.exec();
}

运行结果：

主窗口设计

应用程序设计中的自定义对话框

  • 自定义对话框的重要性 在设计应用程序时，为了实现特定的功能，有时需要设计自定义对话框。这些对话框可以为用户提供交互界面，以便用户输入数据或选择操作。

自定义对话框的继承和设计

  • 继承关系 自定义对话框一般从QDialog类继承，以获取标准对话框的功能和特性。
  • 设计方法 可以使用Qt Designer进行可视化设计，以便更直观地创建对话框界面。

对话框的使用步骤

  • 创建对话框 首先需要创建一个自定义对话框的实例或对象。
  • 传递数据给对话框 如果需要，可以向对话框传递数据，以便在对话框中使用或显示。
  • 显示对话框并获取输入 通过调用对话框的显示方法，将对话框展示给用户，并等待用户输入或选择。
  • 判断对话框的返回类型 在对话框关闭时，通常需要判断用户是如何关闭对话框的（例如，通过点击"确定"按钮还是"取消"按钮），这可以通过判断对话框的返回类型来实现。
  • 获取对话框输入数据 在用户完成输入后，需要从对话框中获取用户输入的数据，以便在应用程序中使用。

多窗口应用程序设计

常用窗口基类：

类名称 描述 主要用途
QWidget 是所有用户界面对象的基类。它是构建其他 Qt 窗口部件的基础。 提供基本的窗口部件功能，如绘制、事件处理和布局管理等。
QDialog 是一个用于显示对话框的窗口类。对话框通常用于与用户进行短暂且特定的交互。 用于创建各种类型的对话框，如信息框、警告框、输入对话框等。
QMainWindow 是一个提供主应用程序窗口的类。它通常包含菜单栏、工具栏、状态栏等组件。 作为应用程序的主窗口，提供丰富的用户界面元素和组织结构。

这三个类都是 Qt 框架中用于创建图形用户界面的重要部分。

QWidget 是所有用户界面对象的基石，而 QDialog 和 QMainWindow 都是 QWidget 的派生类，用于创建特定类型的窗口。

  • QWidget 提供了一组基本的工具和接口，用于创建自定义控件和布局。
  • QDialog 通常用于显示短暂的、特定的信息或请求用户输入。
  • QMainWindow 则用于构建复杂的应用程序界面，提供了菜单栏、工具栏等标准元素，并且可以包含其他窗口部件。

QWidget重要特性设置

在Qt框架中，窗口基类的选择对于创建GUI项目至关重要。常用的窗口基类包括QWidget、QDialog和QMainWindow，它们各自具有不同的特性和用途。

QWidget类

QWidget是所有Qt窗口的基类，提供了窗口的基本功能和属性。它本身不具有特定的窗口外观，但可以继承并扩展其功能。其他继承自QWidget的类，如QSplashScreen和QMdiSubWindow，分别具有特定的用途，如Splash窗口和MDI子窗口。

QDialog类

QDialog通常用于创建对话框窗口，用于临时显示信息或获取用户输入。它不同于QMainWindow，通常没有菜单栏和工具栏等主界面元素。

QMainWindow类

QMainWindow常作为多窗口应用程序的主界面窗口使用。它提供了标题栏、菜单栏、工具栏等标准桌面应用程序的元素。

在创建多窗口应用程序时：

  • 主界面窗口一般基于QMainWindow类创建，以满足其特定的功能和外观需求。
  • 其他类型的窗口可以根据需求灵活选择QMainWindow、QWidget或QDialog等类来创建。这些窗口可以单独显示，也可以嵌入主界面窗口中。

关于窗口的特性和运行方式：

通过QWidget类的相关函数，如setAttribute()、setWindowFlag()和setWindowState()等，可以设置和控制窗口的各种特性和运行状态，如窗口的属性、标志和状态等。

1、函数setAttribute

函数setAttribute)用于设置窗口的一些属性，其函数原型定义如下:

plain 复制代码 
void Qwidget::setAttribute(Qt::WidgetAttribute attribute,bool on = true)

枚举类型Qt:Widget.Attribute定义了窗口的一些属性，可以启用或取消启用这些属性。枚举类型Qt::WidgetAttribute有几十个枚举常量。

枚举常量

属性标志 描述
Qt::WA_AcceptDrops 该属性决定是否允许窗口接受拖放操作。如果设置了此属性，窗口将接受拖放操作，并允许处理拖放事件。
Qt::WA_AlwaysShowToolTips 设置此属性后，工具提示（tooltips）将始终显示，即使鼠标没有悬停在控件上。
Qt::WA_DeleteOnClose 设置此属性后，当窗口关闭时，窗口对象的内存将被自动删除。这是一个用于快速关闭小部件（如弹出窗口）的便捷选项。
Qt::WA_Hover 设置此属性后，窗口将支持鼠标悬停事件。这意味着当你的鼠标悬停在窗口上时，即使没有点击或按键操作，也可以触发事件。
Qt::WA_MouseTracking 设置此属性后，即使鼠标没有在窗口上按下按钮，窗口也会跟踪鼠标的移动，并发送鼠标移动事件。
Qt::WA_AcceptTouchEvents 设置此属性后，窗口将接受触摸事件。这对于支持触摸输入的设备上的应用程序很有用。

2、函数setWindowFlag

QWidget 的 windowFlags属性表示窗口的特性，属性值是标志类型Qt:WindowFlags，是枚举类型Qt:WindowType的枚举值的组合。

QWidget有一个函数setWindowFlag0)用于一次设置一个特性，可单独启用或取消启用某个特性，其函数原型定义如下:

plain 复制代码 
void Qwidget : :setWindowFlag(Qt : : windowType flag,bool on = true)

枚举类型Qt::WindowType的枚举值比较多，根据作用可以分为几个大类，其中用于表示窗口类型的枚举常量

枚举常量：

窗口类型 描述
Qt::Widget 这是所有用户界面对象的基类。任何自定义的窗口或控件都应继承自 QWidget 。它提供了基本的对象管理功能和一些通用界面操作。
Qt::Window 这是一种普通的窗口类型，提供了常规窗口的行为和属性，如可以调整大小、可以移动等。一个应用的主窗口通常是这种类型。
Qt::Dialog 对话框窗口类型，通常用于显示需要用户输入或选择信息的界面。对话框通常具有模态行为，意味着在关闭对话框之前，用户无法与其他窗口交互。
Qt::Popup 弹出窗口类型，这种窗口不占据屏幕上的空间，不会阻止用户与其他窗口交互。常用于显示临时信息或工具提示。
Qt::Tool 工具窗口类型，通常用于工具箱应用程序中的面板或窗口部件。这些窗口在操作系统桌面上表现为小的面板或工具条。
Qt::ToolTip 用于显示工具提示的窗口类型。工具提示通常在鼠标悬停时显示额外的信息。这种窗口是临时的，通常在短时间内自动消失。
Qt::SplashScreen 用于显示启动屏幕的窗口类型。在应用程序启动时显示，通常包含品牌信息或欢迎画面。
Qt::SubWindow 子窗口类型，通常作为主窗口的一部分存在，可以浮动或停靠在主窗口上。它们有自己的标题栏和移动能力，但通常会受到主窗口的控制。

Qt:Widget、Qt:Window等表示窗口类型的枚举常量可以使窗口具有默认的外观设置，例如设置为Qt:Dialog类型的窗口具有对话框的默认外观，标题栏没有最小化和最大化按钮。

枚举类型Qt:WindowType中用于控制窗口显示效果和外观的枚举常量如表7-5所示。可以通过函数setWindowFlag()设置窗口的特性，定制窗口外观，例如可以设置一个窗口只有最小化和最大化按钮，没有关闭按钮。要自定义窗口外观，需要先启用Qt::CustomizeWindowHint特性。

3、函数setWindowState

函数setWindowState()可使窗口处于最小化、最大化等状态，其函数原型定义如下:

4、函数setWindowModality

属性 windowModality表示窗口的模态类型，只对窗口有用。

5、函数setWindowOpacity

属性 windowOpacity表示窗口的透明度，函数setWindowOpacity()用于设置该属性的值。

MDI应用程序设计

基本概念

  • 多文档界面（MDI）是一种应用程序结构，适用于处理特定类型的文件。
  • MDI应用程序包含一个主窗口和任意多个子窗口。
  • 活动子窗口是获得输入焦点的子窗口，通常共享主窗口的工具栏和菜单。

MDI应用程序设计的主要元素

  • QMdiArea类：提供MDI应用程序中的主区域，用于容纳子窗口。
  • QMdiSubWindow类：代表一个子窗口，可以在QMdiArea中打开和关闭。

操作与功能

  • 主窗口工具栏上的按钮（如"复制"、"粘贴"、"字体设置"等）针对当前活动的子窗口进行操作。
  • 子窗口有两种显示模式：可以通过QMdiArea::setViewMode()函数进行设置。

工作流程或特点

  • 用户可以通过MDI应用程序打开多个子窗口，处理不同类型的文件。
  • 主窗口提供工具和功能，作用于当前活动的子窗口。
  • 子窗口之间的切换和操作通过主窗口的工具栏和菜单实现。

子窗口模式（MDI）

定义：子窗口模式通常使用 QMdiArea 和 QMdiSubWindow 类，在一个主窗口中可以打开多个独立的子窗口，每个子窗口可以独立操作。

特点：

  • 每个子窗口是独立的，可以单独最大化、最小化、关闭。
  • 适合处理多个文档或视图。

示例：

cpp 复制代码 
#include <QApplication>
#include <QMainWindow>
#include <QMdiArea>
#include <QMdiSubWindow>
#include <QTextEdit>
#include <QToolBar>
#include <QAction>

class MainWindow : public QMainWindow {
public:
    MainWindow() {
        QMdiArea *mdiArea = new QMdiArea;
        setCentralWidget(mdiArea);
        createActions(mdiArea);
        setWindowTitle("MDI Example");
    }

private:
    void createActions(QMdiArea *mdiArea) {
        QAction *newWindowAction = new QAction("New Window", this);
        connect(newWindowAction, &QAction::triggered, [mdiArea]() {
            QTextEdit *textEdit = new QTextEdit;
            QMdiSubWindow *subWindow = mdiArea->addSubWindow(textEdit);
            subWindow->setWindowTitle("Document");
            subWindow->show();
        });
        
        QToolBar *toolbar = addToolBar("Main Toolbar");
        toolbar->addAction(newWindowAction);
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    MainWindow mainWindow;
    mainWindow.resize(800, 600);
    mainWindow.show();
    return app.exec();
}

运行结果：

QMdiArea

基本概念：

  1. 多文档界面（MDI）是一种应用程序结构，适用于处理特定类型的文件。
  2. MDI应用程序包含一个主窗口和任意多个子窗口。
  3. 活动子窗口是获得输入焦点的子窗口，通常共享主窗口的工具栏和菜单。

MDI应用程序设计的主要元素：

  1. QMdiArea类：提供MDI应用程序中的主区域，用于容纳子窗口。
  2. QMdiSubWindow类：代表一个子窗口，可以在QMdiArea中打开和关闭。

操作与功能：

  1. 主窗口工具栏上的按钮（如"复制"、"粘贴"、"字体设置"等）针对当前活动的子窗口进行操作。
  2. 子窗口有两种显示模式：可以通过QMdiArea::setViewMode()函数进行设置。

工作流程或特点：

  1. 用户可以通过MDI应用程序打开多个子窗口，处理不同类型的文件。
  2. 主窗口提供工具和功能，作用于当前活动的子窗口。
  3. 子窗口之间的切换和操作通过主窗口的工具栏和菜单实现。
QMdiSubWindow

QMdiSubWindow ：

  • 定义： QMdiSubWindow 是 Qt 框架中的一个类，用于管理 MDI（多文档界面）应用程序中的子窗口。
  • 角色：它是 MDI 应用程序中子窗口的实现，其内部组件代表了实际的用户窗口。

QMdiSubWindow 的主要功能和特点

  • widget() 函数：
    • 功能：返回用户窗口对象的指针。
    • 用途：当需要操作用户窗口时，可以通过这个函数获取到用户窗口的指针，并进行相应的操作。
  • setWidget() 函数：
    • 功能：设置用户窗口作为 QMdiSubWindow 的内部组件。
    • 一般用法：通常不需要直接调用此函数，因为在 MDI 区域内添加子窗口时，会自动为用户窗口创建 QMdiSubWindow 并将其设为父容器。

QMdiArea 与 QMdiSubWindow 的关系

  • QMdiArea：是 MDI 应用程序中的主窗口区域，用于管理多个子窗口。
  • 当使用 QMdiArea::addSubWindow() 函数添加用户窗口时，系统会自动为这个用户窗口创建一个 QMdiSubWindow 窗口，并将其作为父容器。这样， QMdiArea 就可以通过 QMdiSubWindow 来管理和控制这些子窗口。

使用 QMdiSubWindow 的场景

  • 在开发 MDI 应用程序时， QMdiSubWindow 常常被用来创建和管理多个独立的文档或视图，每个文档或视图都有自己的 QMdiSubWindow 实例。

多页模式（Tab Widget）

定义：多页模式通常使用 QTabWidget 类，将多个页面放置在同一个窗口中，通过标签页进行切换。

特点：

  • 各个页面在同一个窗口中，无需单独窗口。
  • 适合组织相关功能或数据，使用户在多个视图间快速切换。

示例：

cpp 复制代码 
#include <QApplication>
#include <QTabWidget>
#include <QTextEdit>
#include <QVBoxLayout>
#include <QWidget>

class MainWindow : public QWidget {
public:
    MainWindow() {
        QTabWidget *tabWidget = new QTabWidget;
        tabWidget->addTab(createTextEdit(), "Tab 1");
        tabWidget->addTab(createTextEdit(), "Tab 2");
        tabWidget->addTab(createTextEdit(), "Tab 3");

        QVBoxLayout *layout = new QVBoxLayout;
        layout->addWidget(tabWidget);
        setLayout(layout);
        setWindowTitle("Tab Widget Example");
    }

private:
    QTextEdit *createTextEdit() {
        return new QTextEdit("This is a text edit area.");
    }
};

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    MainWindow mainWindow;
    mainWindow.resize(400, 300);
    mainWindow.show();
    return app.exec();
}

运行结果：

Splash与登录窗口

Splash无边框窗口

Splash Screen（启动画面） 是一种常见的无边框窗口，通常在应用程序启动时显示，用于展示程序的品牌标识或加载信息。Qt提供了 QSplashScreen 类来方便地创建此类窗口。

主要特点

  • 无边框：Splash窗口一般没有标题栏和边框，旨在吸引用户的注意力。
  • 可自定义：可以显示任何图像、文本或进度条。
  • 支持透明：可以设置透明背景以增加视觉效果。

创建Splash Screen的步骤

  • 创建一个 QSplashScreen 对象，并传入要显示的图像。
  • 显示Splash Screen，通常使用 show() 方法。
  • 在载入应用程序的过程中，可以使用 QApplication::processEvents() 来更新Splash Screen。
  • 关闭Splash Screen，使用 close() 方法。

示例：

以下是一个简单的Qt示例，展示如何创建和使用Splash Screen：

cpp 复制代码 
#include <QApplication>
#include <QSplashScreen>
#include <QTimer>
#include <QPixmap>
#include <QMainWindow>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    // 创建QSplashScreen对象
    QPixmap pixmap(":/images/splash.png"); // 使用资源文件或路径
    QSplashScreen splash(pixmap);
    splash.show();

    // 模拟应用程序启动过程
    QTimer::singleShot(5000, &splash, &QSplashScreen::close); // 5秒后关闭Splash

    // 创建主窗口
    QMainWindow mainWindow;
    mainWindow.setWindowTitle("My Application");
    mainWindow.resize(800, 600);

    // 显示主窗口
    mainWindow.show();

    // 进入事件循环
    return app.exec();
}

代码解析

  1. 创建Splash Screen：使用 QPixmap 加载图像，并创建 QSplashScreen 对象。
  2. 显示Splash Screen：调用 splash.show() 以展示启动画面。
  3. 模拟加载业务：使用 QTimer::singleShot 模拟五秒的加载时间，之后自动关闭Splash Screen。
  4. 显示主窗口：创建并显示主应用程序窗口。
相关推荐
用户805533698033 天前
不止三件套：QObject 属性系统全关键字与运行时反射!
c++·qt
xcyxiner3 天前
DicomViewer (vcpkg Windows和ubuntu编译)7
qt
Quz8 天前
QML Hello World 入门示例
qt
xcyxiner11 天前
DicomViewer (dcmtk读取dcm文件)5
qt
xcyxiner12 天前
DicomViewer (后台线程处理文件)4
qt
xcyxiner12 天前
DicomViewer (添加模型类)3
qt
xcyxiner13 天前
DicomViewer (目录调整) 2
qt
xcyxiner13 天前
dcmtk vtk vtk-dicom(gdcm) 编译(debug) v2
qt
桥田智能15 天前
桥田智能 QT-650S：面向白车身焊装的 800kg 重载快换解决方案
开发语言·qt·系统架构
森G15 天前
75、服务器源码解析---------云视频服务项目
linux·服务器·网络·c++·qt
热门推荐
012026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf022026年6月AI大模型全景报告：GPT-5.6、Claude Opus 4.8、Gemini 3.5，中美AI三足鼎立谁主沉浮？032026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？04Trae国际版与国内版深度测评：AI原生IDE的双生花05GitHub 镜像站点06飞书长连接_事件订阅（接收消息，审批任务状态变更）07【AI】2026 年具身智能模型和世界模型总结08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析092026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？102026年AI架构实战：彻底解决OpenAI接口超时与封号，Python调用GPT-5.2/Sora2企业级架构详解（附源码+压测报告）