devbox
寸_铁
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

QT之QWebEngineView详细介绍

作者：寸_铁 | 2024-07-17 08:34:40

赞

踩

qwebengineview

此篇文章来源于自己学习QT的QWebEngineView类总结的知识点，本人能力有限，若文章有其他错误，大家评论区评论，共同学习，共同进步。

一、QWebEngineView介绍

QWebEngineView是Qt框架中的一个组件，它是基于Chromium内核的Web浏览器引擎，用于在Qt应用程序中嵌入网页内容和实现各种Web应用功能。通过QWebEngineView，开发者可以在本地桌面应用程序中轻松地集成网页浏览功能，支持HTML5、CSS3、JavaScript等现代Web技术。

注意：QWebEngineView类仅支持QT的5.4版本以上，之前的版本都是使用QtWebKit，QtWebKit类在5.4版本以上已经被丢弃了，不能使用了。而对于QWebEngineView类，仅仅支持MSVC的编译器并不支持MinGW。

  1. 加载并显示网页内容。
  2. 与网页中的JavaScript进行交互。
  3. 监听和处理网页加载完成、加载失败等各种信号槽事件。
  4. 实现网页导航控制（前进、后退、刷新）等功能。

在Qt Quick中，对应的功能类为QQuickWebEngineView，用于在QML场景中嵌入Web内容。

例如，创建并加载一个网页的基本用法如下：

  1. #include <QWebEngineView>
  2. #include <QApplication>
  3.  
  4. int main(int argc, char *argv[])
  5. {
  6.     QApplication app(argc, argv);
  7.  
  8.     QWebEngineView view;
  9.     view.load(QUrl(QStringLiteral("http://www.example.com")));
  10.     view.show();
  11.  
  12.     return app.exec();
  13. }

以上代码会创建一个QWebEngineView窗口，并加载example.com网站的内容。

二、成员函数

1、QWebEngineView::QWebEngineView(QWidget *parent = Q_NULLPTR)

QWebEngineView::QWebEngineView(QWidget *parent = Q_NULLPTR) 是Qt WebEngine模块中用于创建一个QWebEngineView对象的构造函数。

参数 parent 指向一个QWidget指针，它是QWebEngineView的父窗口或父控件。如果不传入参数（使用默认值Q_NULLPTR），则QWebEngineView将成为一个顶级窗口。如果指定了父控件，那么QWebEngineView将作为该父控件的子控件存在，并遵循父控件的生命周期和布局规则。

简而言之，这段代码：

QWebEngineView *webView = new QWebEngineView(parentWidget);

将会创建一个新的QWebEngineView实例，并将其父控件设置为parentWidget。如果需要在窗口中显示一个能够浏览网页内容的视图，这就是创建该视图的基本步骤。随后可以调用webView->load(QUrl(url))来加载指定的网页URL。

2、void QWebEngineView::back()

void QWebEngineView::back() 是Qt WebEngine模块中的一个成员函数，应用于QWebEngineView类。该函数的作用是让QWebEngineView中的网页浏览器历史回退一步，即显示上一个访问过的网页。

在实际应用中，如果你有一个QWebEngineView对象（比如命名为webView），并且用户已经在该浏览器控件中浏览了几个网页，调用 webView->back(); 就会让浏览器返回到前一个页面，就像在常规Web浏览器中点击“后退”按钮一样。

以下是一个使用QWebEngineView和back()函数的简单代码示例：

  1. #include <QApplication>
  2. #include <QWebEngineView>
  3. #include <QUrl>
  4.  
  5. int main(int argc, char *argv[])
  6. {
  7.     QApplication app(argc, argv);
  8.  
  9.     // 创建一个QWebEngineView实例
  10.     QWebEngineView* webView = new QWebEngineView();
  11.  
  12.     // 加载一个网页
  13.     webView->load(QUrl("https://www.example.com"));
  14.  
  15.     // 显示QWebEngineView
  16.     webView->show();
  17.  
  18.     // 假设用户已经浏览了一些页面，现在模拟点击“后退”按钮
  19.     if (webView->history()->canGoBack()) {
  20.         webView->back(); // 回退到上一个页面
  21.     }
  22.  
  23.     return app.exec();
  24. }

在这个例子中，首先创建了一个QWebEngineView实例，并加载了一个网页。然后，检查webView的历史记录中是否可以回退（即是否至少有两个页面），如果可以，则调用back()函数来实现页面回退的功能。在实际应用中，通常会将back()函数的调用绑定到一个按钮的点击事件上，以供用户手动触发页面回退行为。

3、void QWebEngineView::forward()

void QWebEngineView::forward() 是Qt WebEngine模块中的一个成员函数，用于QWebEngineView类。这个函数的作用是在网页浏览历史中向前推进一步，即显示下一个访问过的网页。

在实际应用中，如果你有一个QWebEngineView对象（例如 webView），并且用户已经在该浏览器控件中浏览了若干网页，并且当前处于历史记录的前一个页面，调用 webView->forward(); 就会让浏览器跳转到下一个页面，就如同在常规Web浏览器中点击“前进”按钮一样。

下面是一个使用forward()函数的基本示例：

  1. #include <QApplication>
  2. #include <QWebEngineView>
  3. #include <QUrl>
  4.  
  5. int main(int argc, char *argv[])
  6. {
  7.     QApplication app(argc, argv);
  8.  
  9.     // 创建一个QWebEngineView实例
  10.     QWebEngineView* webView = new QWebEngineView();
  11.  
  12.     // 加载一个初始网页
  13.     webView->load(QUrl("https://www.example.com"));
  14.  
  15.     // 用户浏览了其他页面，现在假设已经按后退按钮回到了之前的页面
  16.     if (webView->history()->canGoForward()) { // 检查是否可以前进到下一个页面
  17.         webView->back(); // 先模拟后退一步
  18.         webView->forward(); // 然后模拟前进到下一个页面
  19.     }
  20.  
  21.     // 显示QWebEngineView
  22.     webView->show();
  23.  
  24.     return app.exec();
  25. }

在这个示例中，我们首先加载了一个网页，然后假设用户进行了后退操作，并检查是否可以前进。如果可以，我们就调用forward()函数，让浏览器显示下一个页面。在真实应用中，通常会将forward()函数绑定到一个“前进”按钮的点击事件上。

4、void QWebEngineView::iconChanged(const QIcon &icon)

void QWebEngineView::iconChanged(const QIcon &icon) 是Qt WebEngine模块中QWebEngineView类的一个信号。当加载的网页图标（favicon）发生变化时，这个信号会被发射。

这个信号并没有一个对应的成员函数，而是作为一种通知机制，允许您连接到一个槽函数来响应网页图标的变化。例如，当您希望在地址栏或者书签中更新网页对应的图标时，可以这样做：

  1. QObject::connect(webView, &QWebEngineView::iconChanged, [=](const QIcon &newIcon){
  2.     // 更新地址栏或书签栏中的图标
  3.     addressBar->setIcon(newIcon);
  4.     bookmarksManager->updateBookmarkIcon(currentUrl, newIcon);
  5. });
  6.  
  7. // 或者在槽函数中处理
  8. connect(webView, SIGNAL(iconChanged(QIcon)), this, SLOT(updatePageIcon(QIcon)));
  9.  
  10. //槽函数
  11. void YourClass::updatePageIcon(const QIcon &icon) {
  12.     // 在这里处理图标变化，例如更新UI中的图标
  13.     myStatusIcon->setIcon(icon);
  14. }

请注意，上面的代码展示了Qt 5中的信号与槽连接方式，对于Qt 5.14及以后的版本，推荐使用lambda表达式或connect函数的第一个形式来连接信号和槽。在Qt 4风格的信号槽语法中，使用SIGNAL和SLOT宏。

5、void QWebEngineView::iconUrlChanged(const QUrl &url)

void QWebEngineView::iconUrlChanged(const QUrl &url) 是Qt WebEngine模块中QWebEngineView类的一个信号。当网页的图标URL（favicon URL）发生变化时，该信号会被发射。这个信号携带了一个QUrl类型的参数，该参数包含了新的图标资源的URL。

这个信号常用于监控网页favicon的更新，当网页的图标URL变化时，您可以连接到这个信号，并根据新的URL获取和更新对应的图标资源。

例如，通过信号槽机制，您可以捕获这个信号并做出相应动作：

  1. QObject::connect(webView, &QWebEngineView::iconUrlChanged, [&](const QUrl &newIconUrl){
  2.     // 新的图标URL已改变，可以在此处根据新的URL下载并更新图标
  3.     // 下面的代码仅为示意，实际应用中可能需要异步下载并处理图标数据
  4.     QImage iconImage = QImageReader(newIconUrl).read();
  5.     if (!iconImage.isNull()) {
  6.         myStatusBar->setIcon(QIcon(iconImage));
  7.     }
  8. });

void QWebEngineView::iconChanged(const QIcon &icon) 和 void QWebEngineView::iconUrlChanged(const QUrl &url) 是Qt WebEngine模块中QWebEngineView类的两个不同信号，它们的区别在于提供的信息和处理方式：

  1. iconChanged(const QIcon &icon)：

    • 这个信号是在网页的图标（favicon）实际内容发生变化时触发的。
    • 当网页的favicon加载完成或更新时，该信号会直接传递一个已经解析并加载好的图标对象（QIcon）。
    • 开发者可以直接使用这个图标对象更新UI，无需关心具体的URL和加载过程。

  2. iconUrlChanged(const QUrl &url)：

    • 这个信号在网页的favicon URL发生变化时触发。
    • 该信号只提供新的图标资源的URL地址，而不提供已解析的图标数据。
    • 开发者需要根据这个URL自行加载图片资源（例如通过QImageReader等工具），然后转换成QIcon对象，最后更新UI。

总结来说，iconChanged 提供了 favicon 图片的实体数据，可以直接用于界面更新；而 iconUrlChanged 提供的是图片资源的网址，开发者需要进一步处理才能获取到图片数据。在实际应用中，根据需求可以选择监听其中一个或两个信号，前者更适合快速更新UI，后者则提供了更大的灵活性，但需要额外的处理步骤。

6、void QWebEngineView::loadFinished(bool ok)

void QWebEngineView::loadFinished(bool ok) 是Qt WebEngine模块中QWebEngineView类的一个信号。当网页加载完毕时，不论加载成功与否，该信号都会被触发。

参数 bool ok 表示加载操作是否成功。如果 ok 为 true，则表示网页加载顺利完成；如果为 false，则表示加载过程中遇到了错误或中断。

开发者通常会连接到这个信号来执行网页加载完成后的后续操作，例如：

  1. QObject::connect(webView, &QWebEngineView::loadFinished, [=](bool success){
  2.     if (success) {
  3.         qDebug() << "Web page loaded successfully.";
  4.         // 执行加载成功后的操作，例如隐藏进度条、启用UI元素等
  5.     } else {
  6.         qDebug() << "Failed to load web page!";
  7.         // 执行加载失败后的操作，例如显示错误信息、尝试重新加载等
  8.     }
  9. });

这个信号非常重要，因为它可以帮助开发者跟踪网页加载的状态，并根据加载结果执行相应的程序逻辑。

7、void QWebEngineView::loadProgress(int progress)

void QWebEngineView::loadProgress(int progress) 是Qt WebEngine模块中QWebEngineView类的一个信号。当网页加载的过程中，这个信号会被周期性地发射，告知当前加载的进度百分比。

参数 int progress 是一个介于0到100之间的整数，代表网页加载的进度。0表示加载尚未开始或刚刚开始，100表示加载已完成。

开发者可以连接到这个信号来实时显示网页加载的进度，例如在进度条上反映出来

  1. QObject::connect(webView, &QWebEngineView::loadProgress, [=](int currentProgress){
  2.     progressBar->setValue(currentProgress);
  3.     // 这里的progressBar是一个QProgressBar对象，用于显示加载进度
  4. });

这样一来，每当网页加载的进度发生变化时，进度条就会相应地更新其值，让用户直观地了解到加载的过程。

8、void QWebEngineView::loadStarted()

void QWebEngineView::loadStarted() 是Qt WebEngine模块中QWebEngineView类的一个信号。当QWebEngineView开始加载一个网页时，该信号会被立即触发。

开发者通常会连接到这个信号来执行网页加载开始时的一些操作，例如显示加载动画、禁用某些交互功能等，以表明网页正在加载中。以下是一个简单的示例：

  1. QObject::connect(webView, &QWebEngineView::loadStarted, [=](){
  2.     // 显示加载进度条或加载动画
  3.     loadingIndicator->start();
  4.     // 禁止用户与界面的某些交互
  5.     someInteractiveWidget->setEnabled(false);
  6.     qDebug() << "Web page loading started...";
  7. });

在这段代码中，当网页加载开始时，loadingIndicator（加载指示器）会被启动，同时某个交互式小部件（someInteractiveWidget）会被禁用，以防止用户在加载期间进行无效的操作。同时，控制台会打印一条消息表示加载已经开始。

9、void QWebEngineView::reload()

void QWebEngineView::reload() 是Qt WebEngine模块中的 QWebEngineView 类的一个成员函数。调用此函数会导致当前在 QWebEngineView 视图中加载的网页重新加载。这意味着它会终止当前页面的加载（如果还在加载中），并从服务器重新获取该页面的最新版本。

在实际应用中，可能在需要更新网页内容或者处理网页刷新逻辑时使用此方法。例如，当用户点击刷新按钮或者程序需要确保显示的是最新网页数据时，可以调用 reload() 函数来实现页面刷新。

以下是调用该函数的基本示例：

  1. QWebEngineView *webView = new QWebEngineView(parent);
  2. // ... 进行视图初始化及加载URL等操作 ...
  3. // 当需要刷新页面时
  4. webView->reload();

10、void QWebEngineView::renderProcessTerminated(QWebEnginePage::RenderProcessTerminationStatus terminationStatus, int exitCode)

void QWebEngineView::renderProcessTerminated(QWebEnginePage::RenderProcessTerminationStatus terminationStatus, int exitCode) 是Qt WebEngine模块中QWebEngineView类的一个信号。当网页渲染进程突然终止时，这个信号会被触发。

参数说明：

  • QWebEnginePage::RenderProcessTerminationStatus terminationStatus：表示渲染进程结束的状态，它可以是诸如正常退出、异常退出、被浏览器强制结束等各种情况。
  • int exitCode：表示渲染进程的退出代码，对于异常退出等情况，这个代码有助于了解进程为何终止的具体原因。

当收到这个信号时，开发者通常需要处理这种情况，比如重新加载网页、显示错误提示或者记录日志等。例如：

  1. QObject::connect(webView, &QWebEngineView::renderProcessTerminated, [&](QWebEnginePage::RenderProcessTerminationStatus status, int code){
  2.     switch (status) {
  3.     case QWebEnginePage::NormalTerminationStatus:
  4.         qDebug() << "Render process terminated normally with exit code:" << code;
  5.         // 可能处理正常结束的逻辑
  6.         break;
  7.     case QWebEnginePage::AbnormalTerminationStatus:
  8.         qDebug() << "Render process terminated abnormally with exit code:" << code;
  9.         // 可能需要重新加载页面或其他恢复措施
  10.         webView->reload();
  11.         break;
  12.     case QWebEnginePage::CrashedStatus:
  13.         qDebug() << "Render process crashed with exit code:" << code;
  14.         // 可能需要显示错误信息或采取其他错误处理策略
  15.         QMessageBox::critical(nullptr, "Error", "The render process has crashed.");
  16.         break;
  17.     default:
  18.         // 其他未知情况的处理
  19.         break;
  20.     }
  21. });

11、void QWebEngineView::selectionChanged()

void QWebEngineView::selectionChanged() 是Qt WebEngine模块中QWebEngineView类的一个信号。当用户在网页中更改文本选择（例如高亮选中文本）时，这个信号会被触发。

当您连接到此信号时，可以编写相应的槽函数来接收通知，并据此执行相应的操作，比如获取当前选中的文本、复制到剪贴板，或者做其他的文本处理工作。以下是一个基本的示例：

  1. QObject::connect(webView, &QWebEngineView::selectionChanged, [=]() {
  2.     QString selectedText = webView->selectedText();
  3.     qDebug() << "Selected text changed to: " << selectedText;
  4.     // 在这里可以处理选中文本的变化，比如显示到另一个控件，或者保存到剪贴板等操作
  5. });

当网页中的文本选择发生变化时，上述代码会捕获到这个事件，并打印出当前选中的文本。

12、void QWebEngineView::stop()

void QWebEngineView::stop() 是Qt WebEngine模块中QWebEngineView类的一个成员函数。当调用这个函数时，它会停止当前正在加载或渲染的网页。也就是说，如果QWebEngineView正在加载一个网页，或者执行JavaScript脚本、播放媒体等操作，调用此函数将会中止这些活动。

在实际应用中，这个函数常常被用于用户取消加载或者遇到网络问题需要提前结束加载任务的情况。例如，当用户按下“停止加载”按钮时：

  1. QPushButton *stopButton = new QPushButton("Stop Loading", this);
  2. QObject::connect(stopButton, &QPushButton::clicked, webView, &QWebEngineView::stop);

13、void QWebEngineView::titleChanged(const QString &title)

void QWebEngineView::titleChanged(const QString &title) 是Qt WebEngine模块中QWebEngineView类的一个信号。当网页标题发生变化时，该信号会被触发，参数 title 包含的是新的网页标题字符串。

在Web应用开发中，开发者通常会连接到这个信号来更新应用程序界面中的标题栏或标签，以便反映出当前网页的实际标题。例如：

  1. QObject::connect(webView, &QWebEngineView::titleChanged, [=](const QString &newTitle){
  2.     // 更新窗口标题栏或自定义的标题显示控件
  3.     windowTitleBar->setText(newTitle);
  4.     // 或者
  5.     this->setWindowTitle(newTitle);
  6. });

在这个例子中，当网页标题发生变化时，窗口标题栏（windowTitleBar）或整个窗口的标题将会被更新为新的网页标题。

14、void QWebEngineView::urlChanged(const QUrl &url)

void QWebEngineView::urlChanged(const QUrl &url) 是Qt WebEngine模块中QWebEngineView类的一个信号。当QWebEngineView中的网页URL发生改变时（例如用户点击链接跳转到新的网页，或者通过JavaScript更改location.href），该信号会被触发。

信号参数 const QUrl &url 指向的是网页当前加载的新URL地址。开发者通常会连接到这个信号来更新相关的UI元素，例如地址栏，或者追踪用户的导航历史，甚至限制用户只能访问预先批准的一系列URL等等。

下面是一个简单的示例，展示如何在URL变化时更新地址栏：

  1. QObject::connect(webView, &QWebEngineView::urlChanged, [=](const QUrl &newUrl){
  2.     addressLineEdit->setText(newUrl.toString()); // 假设addressLineEdit是一个显示当前URL的lineEdit控件
  3. });

当QWebEngineView中的网页URL发生变化时，上述代码将更新addressLineEdit控件的文本内容为新的URL。

15、QWebEngineView::~QWebEngineView()

QWebEngineView::~QWebEngineView() 是Qt WebEngine模块中QWebEngineView类的析构函数。当一个QWebEngineView对象的生命期结束时，系统会自动调用这个析构函数来清理和释放该对象占用的资源。

析构函数的主要作用是：

  1. 清理与QWebEngineView相关的所有资源，例如关闭与之关联的网络请求、释放内存、断开连接的信号槽关系等。
  2. 继承自QObject的析构函数还会自动注销对象，避免产生内存泄漏或悬挂指针。

通常情况下，程序员无需显式调用析构函数，而是由C++的自动内存管理系统在对象超出作用域或被智能指针删除时自动调用。但在一些需要手动管理内存的情况下，如在堆上创建QWebEngineView对象时，应在不再需要该对象时调用delete运算符来释放对象，进而触发析构函数执行清理工作。

16、void QWebEngineView::closeEvent(QCloseEvent *event)

void QWebEngineView::closeEvent(QCloseEvent *event) 是Qt框架中一个覆盖基类QWidget的虚函数。当QWebEngineView窗口接收到关闭事件时（例如用户点击窗口关闭按钮或程序调用了close()函数），该函数会被调用。

在QWebEngineView中重写这个函数可以让你有机会在窗口关闭前执行特定的操作，例如保存当前状态、清理资源、确认用户是否真的想要关闭等。下面是一个简单的示例：

  1. void MyWebEngineView::closeEvent(QCloseEvent *event)
  2. {
  3.     // 如果需要确认用户是否真的要关闭窗口，可以弹出对话框询问
  4.     if (maybeSaveOrCancel()) {
  5.         // 用户同意关闭，接受关闭事件
  6.         event->accept();
  7.     } else {
  8.         // 用户不同意关闭，拒绝关闭事件
  9.         event->ignore();
  10.     }
  11.  
  12.     // 在关闭窗口之前还可以执行其他必要的清理操作
  13.     // ...
  14.  
  15.     // 若未重写此函数，窗口将在接收到关闭事件时直接关闭
  16.     // 通过覆盖此函数，我们可以控制关闭流程
  17. }

在这个示例中，MyWebEngineView是一个继承自QWebEngineView的自定义类，它重写了closeEvent函数。在函数内部，可以根据需要处理关闭事件的行为。

17、void QWebEngineView::contextMenuEvent(QContextMenuEvent *event)

void QWebEngineView::contextMenuEvent(QContextMenuEvent *event) 是Qt WebEngine模块中QWebEngineView类的一个重载事件处理函数。当用户在QWebEngineView控件内右击鼠标时，会触发上下文菜单事件（context menu event），此时这个函数会被调用。

在该函数内部，开发者可以自定义上下文菜单的行为，例如显示自定义的菜单项，或者阻止默认的上下文菜单出现。下面是一个简单的示例：

  1. void MyWebEngineView::contextMenuEvent(QContextMenuEvent *event)
  2. {
  3.     QMenu contextMenu(this);
  4.  
  5.     // 添加自定义菜单项
  6.     QAction *copyAction = contextMenu.addAction(tr("&Copy"));
  7.     connect(copyAction, &QAction::triggered, this, &MyWebEngineView::copySelection);
  8.  
  9.     // 显示自定义的上下文菜单
  10.     contextMenu.exec(event->globalPos());
  11.  
  12.     // 阻止默认的上下文菜单显示
  13.     event->accept();
  14. }
  15.  
  16. // 定义一个槽函数来处理复制操作
  17. void MyWebEngineView::copySelection()
  18. {
  19.     // 获取并复制当前选中的文本
  20.     QString selection = this->selectedText();
  21.     qApp->clipboard()->setText(selection);
  22. }

在上述代码中，当用户在QWebEngineView中右击时，会弹出自定义的上下文菜单，其中包括一个“复制”选项。如果用户点击了“复制”，则会调用copySelection槽函数，将当前选中的文本复制到剪贴板中。同时，调用event->accept()来阻止默认的上下文菜单出现。

18、QWebEngineView *QWebEngineView::createWindow(QWebEnginePage::WebWindowType type)

QWebEngineView *QWebEngineView::createWindow(QWebEnginePage::WebWindowType type) 是Qt WebEngine模块中QWebEngineView类的一个虚拟成员函数。当网页内部触发了一个需要打开新窗口的事件（例如点击了一个<a target="_blank">标签或运行了打开新窗口的JavaScript代码）时，这个函数会被调用。

该函数接收一个枚举参数 QWebEnginePage::WebWindowType type，该参数标识了新窗口的类型，例如新标签页、弹出窗口等。

开发者需要重写这个函数来创建并返回一个新的QWebEngineView实例，以便处理新窗口的打开和显示。如果不重写此函数，默认情况下可能不会创建新窗口或者显示不当。

示例代码：

  1. class CustomWebEngineView : public QWebEngineView
  2. {
  3.     Q_OBJECT
  4. public:
  5.     CustomWebEngineView(QWidget *parent = nullptr) : QWebEngineView(parent) {}
  6.  
  7. protected:
  8.     virtual QWebEngineView *createWindow(QWebEnginePage::WebWindowType type) override
  9.     {
  10.         // 创建并返回一个新的QWebEngineView实例
  11.         auto newView = new QWebEngineView(parentWidget());
  12.         // 可以根据type调整新窗口的外观或行为
  13.         // ...
  14.         return newView;
  15.     }
  16. };

在上述示例中，每当网页内部触发打开新窗口事件时，createWindow函数会被调用，并返回一个新的QWebEngineView实例。开发者可以根据窗口类型来自定义新窗口的行为和样式，比如将其嵌入到现有窗口中，或者作为一个新的窗口显示。

19、void QWebEngineView::dragEnterEvent(QDragEnterEvent *e)

void QWebEngineView::dragEnterEvent(QDragEnterEvent *e) 是Qt WebEngine模块中QWebEngineView类的一个重载事件处理函数。当拖放操作中的鼠标光标进入QWebEngineView控件区域时，会触发dragEnterEvent事件。

这个函数允许你自定义当拖动数据进入QWebEngineView时的行为，比如决定是否接受这次拖放操作。在函数中，可以检查拖放的数据类型，并设置事件的acceptProposedAction()属性来决定是否允许数据在此控件上放下。

  1. void MyWebEngineView::dragEnterEvent(QDragEnterEvent *e)
  2. {
  3.     if (e->mimeData()->hasFormat("text/plain")) // 检查拖动的数据是否是纯文本格式
  4.     {
  5.         e->acceptProposedAction(); // 接受这次拖放操作，允许数据在此控件上放下
  6.     }
  7.     else
  8.     {
  9.         e->ignore(); // 不接受此次拖放操作
  10.     }
  11. }

在这个示例中，如果拖拽的数据类型是纯文本，那么我们允许拖放到QWebEngineView上；否则，忽略这次拖放事件。实际应用中，你可能需要根据你的应用需求来处理不同类型的拖放数据。

20、void QWebEngineView::dragLeaveEvent(QDragLeaveEvent *e)

void QWebEngineView::dragLeaveEvent(QDragLeaveEvent *e) 是Qt WebEngine模块中QWebEngineView类的一个重载事件处理函数。当拖放操作中的鼠标光标离开QWebEngineView控件区域时，会触发dragLeaveEvent事件。

这个函数主要用于处理拖放操作期间鼠标离开视图区域的情况，通常在自定义拖放功能时，可以在这个函数中撤销之前在dragEnterEvent或dragMoveEvent中设置的一些视觉效果或状态。

示例代码：

  1. void MyWebEngineView::dragLeaveEvent(QDragLeaveEvent *e)
  2. {
  3.     // 在这里可以清除之前在dragEnterEvent或dragMoveEvent中设置的任何临时状态或视觉效果
  4.     // 例如，如果在鼠标进入时改变了背景色，这时可以恢复原来的背景色
  5.     setBackgroundColor(originalBackgroundColor);
  6.  
  7.     // 默认情况下，接受该事件
  8.     e->accept();
  9. }

在上述代码中，当拖拽操作离开视图时，视图会恢复到原始背景颜色。实际上，具体的处理逻辑取决于你的应用需求和之前对拖放事件所做的定制。

21、void QWebEngineView::dragMoveEvent(QDragMoveEvent *e)

void QWebEngineView::dragMoveEvent(QDragMoveEvent *e) 是Qt WebEngine模块中QWebEngineView类的一个重载事件处理函数。当拖放操作中的鼠标在QWebEngineView控件区域内移动时，会触发dragMoveEvent事件。

这个函数主要用来处理拖拽过程中鼠标移动时的交互行为，比如可以检测鼠标当前位置，决定是否允许拖放目标区域，并更新相关反馈信息，例如改变鼠标的形状、更新提示信息等。

示例代码：

  1. void MyWebEngineView::dragMoveEvent(QDragMoveEvent *e)
  2. {
  3.     // 检查当前拖放的位置是否满足条件，例如在可接受的范围内
  4.     if (isDropAllowed(e->pos()))
  5.     {
  6.         // 如果允许放下数据，则接受拖动事件
  7.         e->acceptProposedAction();
  8.         // 可以在这里更新界面状态，如改变控件的背景颜色，显示即将放置的提示等
  9.     }
  10.     else
  11.     {
  12.         // 否则，拒绝此次拖动事件
  13.         e->ignore();
  14.     }
  15. }
  16.  
  17. // 示例辅助函数，检查拖放位置是否满足条件
  18. bool MyWebEngineView::isDropAllowed(const QPoint &pos)
  19. {
  20.     // 这里可以根据实际需求判断pos坐标是否在有效范围内
  21.     // 以下代码仅为示例，实际逻辑需根据具体应用场景编写
  22.     QRect rect = this->rect();
  23.     return rect.contains(pos);
  24. }

在上述代码中，当拖拽操作在QWebEngineView内移动时，会检查当前位置是否满足放置数据的条件，如果满足则接受拖动事件，反之则忽略。同时，可以根据实际情况在这个函数内实现更多复杂的拖放逻辑。

22、void QWebEngineView::dropEvent(QDropEvent *e)

void QWebEngineView::dropEvent(QDropEvent *e) 是Qt WebEngine模块中QWebEngineView类的一个重载事件处理函数。当用户在QWebEngineView控件上完成拖放操作（即释放鼠标按钮）时，会触发dropEvent事件。

在该函数中，你可以处理拖放的实际数据交换，获取拖放的数据类型，并将数据应用到QWebEngineView中，例如在网页中插入文本、图片或其他类型的数据。

下面是一个简单的示例：

  1. void MyWebEngineView::dropEvent(QDropEvent *e)
  2. {
  3.     if (e->mimeData()->hasUrls())
  4.     {
  5.         foreach (const QUrl &url, e->mimeData()->urls())
  6.         {
  7.             // 处理URL数据，例如加载拖放的链接
  8.             load(url);
  9.         }
  10.         e->acceptProposedAction();
  11.     }
  12.     else if (e->mimeData()->hasText())
  13.     {
  14.         // 处理文本数据，例如将拖放的文本插入到网页中
  15.         QString text = e->mimeData()->text();
  16.         // 这里假设有一个insertTextToWebPage(text)的函数可以将文本插入到网页中
  17.         insertTextToWebPage(text);
  18.         e->acceptProposedAction();
  19.     }
  20.     else
  21.     {
  22.         e->ignore();
  23.     }
  24. }

在这个示例中，当用户在QWebEngineView上完成拖放操作时，程序会检查拖放的数据类型。如果是URL链接，则加载该链接；如果是文本，则将其插入到网页中。如果数据类型不支持，则忽略这次拖放事件。

23、bool QWebEngineView::event(QEvent *ev)

bool QWebEngineView::event(QEvent *ev) 是Qt框架中QWebEngineView类的一个重载函数。在Qt中，所有继承自QObject的类都可以通过重写event()函数来处理各种事件。这个函数接收一个QEvent指针作为参数，通过检查事件类型并进行适当处理。

在QWebEngineView中，event()函数可以处理所有发送给QWebEngineView对象的事件，包括但不限于键盘输入、鼠标事件、窗口事件等。如果您想自定义QWebEngineView的行为，比如处理一些特殊的事件或扩展默认行为，可以重写这个函数。

以下是一个简单的示例，展示了如何在event()函数中处理特定类型的事件：

  1. bool MyWebEngineView::event(QEvent *ev)
  2. {
  3.     if (ev->type() == QEvent::KeyPress) {
  4.         QKeyEvent *keyEvent = static_cast<QKeyEvent*>(ev);
  5.         // 处理按键事件，例如禁用某个键的功能
  6.         if (keyEvent->key() == Qt::Key_F5) {
  7.             // 禁止F5键刷新页面
  8.             ev->ignore();
  9.             return true;
  10.         }
  11.     }
  12.  
  13.     // 对于未处理的事件，调用父类的event()函数
  14.     return QWebEngineView::event(ev);
  15. }

在上述代码中，当QWebEngineView接收到按键事件时，会检查是否为F5键，如果是，则忽略该事件（不执行默认的刷新页面操作），并返回true表示事件已被处理。对于其他类型的事件，如果没有特殊处理，就交由QWebEngineView的基类来处理。

24、void QWebEngineView::findText(const QString &subString, QWebEnginePage::FindFlags options = QWebEnginePage::FindFlags(), const QWebEngineCallback<bool> &resultCallback = QWebEngineCallback<bool>())

void QWebEngineView::findText(const QString &subString, QWebEnginePage::FindFlags options = QWebEnginePage::FindFlags(), const QWebEngineCallback<bool> &resultCallback = QWebEngineCallback<bool>()) 是Qt WebEngine模块中QWebEngineView类的一个成员函数，用于在网页内容中查找指定的字符串。

函数参数解释：

  • const QString &subString：要在网页中搜索的字符串。

  • QWebEnginePage::FindFlags options：查找选项，可以是以下几种标志的组合（使用|符号连接）：

    • QWebEnginePage::CaseSensitively：区分大小写查找。
    • QWebEnginePage::HighlightAllOccurrences：高亮所有找到的结果。
    • QWebEnginePage::WordStart：从单词开始处查找。
    • 其他可能的查找选项。

  • const QWebEngineCallback<bool> &resultCallback：查找结果回调函数，当查找完成时，会调用这个回调函数，并传入一个布尔值表示是否找到了匹配项。

  1. myWebEngineView.findText("搜索关键词", QWebEnginePage::FindFlags(QWebEnginePage::CaseSensitively | QWebEnginePage::HighlightAllOccurrences),
  2.                        [](bool found) {
  3.                            if (found) {
  4.                                qDebug() << "找到了匹配项";
  5.                            } else {
  6.                                qDebug() << "未找到匹配项";
  7.                            }
  8.                        });

在上述代码中，我们尝试在网页中查找"搜索关键词"，同时设置查找选项为区分大小写并高亮所有匹配项。当查找操作完成时，会调用提供的lambda表达式作为回调函数，输出查找结果。

25、void QWebEngineView::hideEvent(QHideEvent *event)

void QWebEngineView::hideEvent(QHideEvent *event) 是Qt框架中QWebEngineView类的一个重载事件处理函数。当QWebEngineView控件变为不可见（例如，窗口被最小化或隐藏）时，这个函数会被调用。

在实际应用中，重写此函数可以让你在控件隐藏时执行特定的操作，例如暂停视频播放、释放资源以节省内存、记录用户行为等。示例代码如下：

  1. void MyWebEngineView::hideEvent(QHideEvent *event)
  2. {
  3.     // 停止视频播放或其他资源消耗较大的操作
  4.     if (videoPlayer.isPlaying())
  5.         videoPlayer.stop();
  6.  
  7.     // 记录用户隐藏窗口的时间点或其他相关信息
  8.     logUserAction("Web view hidden");
  9.  
  10.     // 调用父类的hideEvent方法以确保Qt默认的隐藏事件处理也能被执行
  11.     QWebEngineView::hideEvent(event);
  12. }

在这个示例中，当QWebEngineView被隐藏时，首先会检查并停止视频播放（这里假设videoPlayer是一个视频播放器对象），然后记录用户的隐藏操作。最后调用父类QWebEngineView的hideEvent方法来执行默认的事件处理逻辑。

26、QWebEngineHistory *QWebEngineView::history() const

QWebEngineHistory *QWebEngineView::history() const 是Qt WebEngine模块中QWebEngineView类的一个成员函数。这个函数返回一个指向QWebEngineHistory对象的指针，该对象提供了对当前QWebEngineView浏览历史的访问。

QWebEngineHistory类提供了很多方法来操作浏览历史，例如：

  • int count()：返回历史记录中的项目总数。
  • QUrl urlAt(int index)：返回指定索引处的历史项目URL。
  • int currentIndex()：返回当前激活页面在历史记录中的索引。
  • void back()：加载历史记录中的前一个页面。
  • void forward()：加载历史记录中的下一个页面。
  • void clear()：清除浏览历史。

通过调用 QWebEngineView::history() 函数，开发者可以获取到QWebEngineView的浏览历史记录，并根据需要进行操作，例如实现前进、后退功能，或者遍历历史记录进行其他操作。

27、void QWebEngineView::load(const QUrl &url)

void QWebEngineView::load(const QUrl &url) 是Qt WebEngine模块中QWebEngineView类的一个成员函数。这个函数用于在QWebEngineView控件中加载指定的URL地址，也就是在该视图中打开并显示指定网页的内容。

使用示例：

  1. #include <QApplication>
  2. #include <QWebEngineView>
  3. #include <QUrl>
  4.  
  5. int main(int argc, char *argv[])
  6. {
  7.     QApplication app(argc, argv);
  8.  
  9.     QWebEngineView webView;
  10.     webView.show();
  11.  
  12.     // 加载一个URL
  13.     QUrl url("https://www.example.com");
  14.     webView.load(url);
  15.  
  16.     return app.exec();
  17. }

在这个示例中，我们创建了一个QWebEngineView对象，并使其可见。接着，我们定义了一个QUrl对象，指向"https://www.example.com"，然后调用`webView.load(url)`来加载并显示该网页。当调用这个函数后，QWebEngineView会开始加载指定的网页，并在加载完成后显示其内容。

28、void QWebEngineView::load(const QWebEngineHttpRequest &request)

void QWebEngineView::load(const QWebEngineHttpRequest &request) 是Qt WebEngine模块中QWebEngineView类的一个成员函数。不同于仅仅通过URL加载网页，这个函数允许你通过一个详细的HTTP请求对象来加载网页内容。

使用此函数，你可以更详细地控制发送给服务器的请求，例如设置HTTP方法（GET、POST等）、添加HTTP头、传输数据体等。

示例代码：

  1. QWebEngineHttpRequest request;
  2. request.setUrl(QUrl("https://example.com/api/data"));
  3. request.setMethod(QWebEngineHttpRequest::Post); // 设置HTTP方法为POST
  4. request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"); // 设置Content-Type头
  5.  
  6. QJsonObject json;
  7. json.insert("key", "value"); // 假设我们要发送JSON数据
  8. QJsonDocument doc(json);
  9. request.setBody(doc.toJson(QJsonDocument::Compact)); // 设置请求体为JSON数据
  10.  
  11. webView.load(request); // 使用自定义的HTTP请求加载数据

在这个示例中，我们创建了一个QWebEngineHttpRequest对象，并设置了URL、HTTP方法、Content-Type头以及请求体。然后我们将这个自定义的HTTP请求对象传递给webView.load(request)函数，以发起一个带有特定参数的HTTP POST请求。这对于需要与服务器进行复杂交互的Web应用尤其有用。

29、QWebEnginePage *QWebEngineView::page() const

QWebEnginePage *QWebEngineView::page() const 是Qt WebEngine模块中QWebEngineView类的一个成员函数。这个函数返回与QWebEngineView关联的QWebEnginePage对象的指针。

QWebEnginePage类提供了更加详细的网页操作接口，比如获取网页内容、执行JavaScript、处理网页加载事件、管理网页cookies、打印网页等。当你需要直接操作或获取与QWebEngineView视图中的网页相关的详细信息时，可以使用这个函数来获取QWebEnginePage对象。

示例：

  1. QWebEngineView *webView = new QWebEngineView(parent);
  2. // 加载网页...
  3. QWebEnginePage *webPage = webView->page();
  4.  
  5. // 现在可以通过webPage对象进行更详细的网页操作
  6. webPage->runJavaScript("console.log('Hello from JavaScript');");

在上述示例中，我们首先创建了一个QWebEngineView对象并加载网页，然后通过调用page()函数获取了与之关联的QWebEnginePage对象，并执行了一个JavaScript命令。

30、void QWebEngineView::load(const QWebEngineHttpRequest &request)

void QWebEngineView::load(const QWebEngineHttpRequest &request) 是Qt WebEngine模块中QWebEngineView类的一个函数，用于根据提供的QWebEngineHttpRequest对象加载网页内容。这个函数允许开发者自定义HTTP请求，包括设置请求方法（如GET、POST等）、请求头和请求体等，从而实现更精细的网页加载控制。

例如，如果你想通过POST方法发送JSON数据到服务器并加载响应的网页内容，可以这样使用：

  1. QWebEngineHttpRequest request;
  2. request.setUrl(QUrl("http://example.com/api/login")); // 设置请求的URL
  3. request.setMethod(QWebEngineHttpRequest::Post); // 设置请求方法为POST
  4.  
  5. QJsonObject json;
  6. json["username"] = "testuser";
  7. json["password"] = "testpass";
  8.  
  9. QJsonDocument doc(json);
  10. request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"); // 设置Content-Type头
  11. request.setBody(doc.toJson()); // 设置请求体为JSON数据
  12.  
  13. QWebEngineView *webView = new QWebEngineView(parentWidget);
  14. webView->load(request); // 使用自定义的HTTP请求加载网页

在上述代码中，我们创建了一个QWebEngineHttpRequest对象，并设置了URL、HTTP方法、Content-Type头以及请求体，然后将这个请求对象传递给QWebEngineView的load函数，以发起一个POST请求到指定的URL，并加载返回的网页内容。

31、QAction *QWebEngineView::pageAction(QWebEnginePage::WebAction action) const

QAction *QWebEngineView::pageAction(QWebEnginePage::WebAction action) const 是Qt WebEngine模块中QWebEngineView类的一个成员函数。这个函数用于获取与给定的QWebEnginePage::WebAction相关的QAction对象。

QWebEnginePage::WebAction是一个枚举类型，列举了一系列与网页操作相关的动作，如后退、前进、刷新、停止加载、复制、粘贴等。当你调用这个函数并传入一个WebAction枚举值时，它会返回一个与该动作关联的QAction对象。

有了这个QAction对象，你就可以将其添加到菜单、工具栏或者关联快捷键，使用户能够方便地执行这些动作。

示例：

  1. QAction *backAction = webView->pageAction(QWebEnginePage::WebAction::Back);
  2. backAction->setShortcut(QKeySequence::Back); // 设置后退按钮的快捷键为Alt+左方向键
  3. menu->addAction(backAction); // 将后退动作添加到菜单中

在上述示例中，我们获取到了与后退操作关联的QAction对象，并为其设置了快捷键，并将其添加到了菜单中。这样，用户就可以通过菜单或快捷键执行后退操作了。

32、void QWebEngineView::setContent(const QByteArray &data, const QString &mimeType = QString(), const QUrl &baseUrl = QUrl())

void QWebEngineView::setContent(const QByteArray &data, const QString &mimeType = QString(), const QUrl &baseUrl = QUrl()) 是Qt WebEngine模块中QWebEngineView类的一个成员函数。这个函数用于将给定的二进制数据加载到QWebEngineView中，并显示为网页内容。

参数解释：

  • const QByteArray &data: 包含要显示的网页内容的二进制数据。这可能是HTML、CSS、JavaScript或者其他符合某种MIME类型的文件内容。
  • const QString &mimeType: 指定数据的MIME类型，例如 "text/html"、"image/jpeg" 等。如果省略此参数，默认为空字符串，通常在这种情况下，如果数据看起来像HTML，WebKit引擎会尝试将其当作HTML处理。
  • const QUrl &baseUrl: 指定基础URL，用于解析相对URL。如果省略此参数，默认为空QUrl。在处理包含相对URL的文档时，基础URL是非常重要的，因为它会影响资源加载路径的解析。

使用示例：

  1. QByteArray htmlData = "<html><body><h1>Hello, World!</h1></body></html>";
  2. QUrl base("http://example.com");
  3. webView->setContent(htmlData, "text/html", base);

上述代码将一段HTML数据加载到QWebEngineView中，并设置了一个基础URL。这样，如果HTML文档中有引用相对路径的资源（如图像、CSS文件等）

33、void QWebEngineView::setHtml(const QString &html, const QUrl &baseUrl = QUrl())

void QWebEngineView::setHtml(const QString &html, const QUrl &baseUrl = QUrl()) 是Qt WebEngine模块中的一个函数，它用于在 QWebEngineView 组件中显示HTML内容。这个函数接受两个参数：

  1. const QString &html: 这是你想要显示的HTML内容字符串。
  2. const QUrl &baseUrl = QUrl(): 这是基础URL，用于解析HTML内容中相对路径的链接和其他资源。如果省略或者留空，默认的基础URL将是空的。

使用示例：

  1. QString htmlContent = "<html><body><h1>Hello, World!</h1></body></html>";
  2. QUrl baseUri("http://example.com"); // 可以留空，表示没有基础URL
  3. myWebEngineView->setHtml(htmlContent, baseUri);

在这段代码中，myWebEngineView 是一个 QWebEngineView 类型的对象，通过调用 setHtml 函数，我们可以把 htmlContent 字符串中的HTML内容显示在这个浏览器组件中，同时指定基础URL为 "http://example.com"。如果HTML内容中有相对路径的链接或引用资源，引擎将使用提供的基础URL来解析它们。

34、void QWebEngineView::setPage(QWebEnginePage *page)

QWebEngineView类的一个函数，用于设置QWebEngineView所使用的QWebEnginePage页面对象。

QWebEngineView是用来显示网页内容的主要视图组件，而QWebEnginePage则是承载网页内容和网页脚本执行环境的实际载体。通过调用 setPage 函数，您可以将一个已经创建好的QWebEnginePage对象赋给QWebEngineView，使视图显示该页面的内容。

例如：

  1. QWebEnginePage *newPage = new QWebEnginePage(this);
  2. // 可以对newPage做进一步的设置，如设置页面代理、设置JavaScript权限等
  3. QWebEngineView *webView = new QWebEngineView(parent);
  4. webView->setPage(newPage);
  5. // 加载网页
  6. newPage->load(QUrl("http://www.example.com"));

在这段代码中，首先创建了一个新的QWebEnginePage对象newPage，然后创建了一个QWebEngineView对象webView，并通过setPage函数将newPage设置为webView要显示的页面，最后加载了一个网址到newPage中，这样webView就会显示这个网页的内容。

35、QWebEngineSettings *QWebEngineView::settings() const

QWebEngineSettings *QWebEngineView::settings() const 是Qt WebEngine模块中QWebEngineView类的一个成员函数。这个函数返回一个指向QWebEngineSettings对象的指针，该对象包含了与QWebEngineView关联的网页渲染和行为相关的各种设置选项。

通过这个函数，您可以获取并修改QWebEngineView的各种高级设置，比如：

  • JavaScript是否启用
  • 是否允许弹出窗口
  • 是否加载图片
  • 是否启用网页插件
  • 是否启用网页存储数据（如cookies、localStorage等）
  • 用户代理字符串设置
  • 网页安全策略等等

示例：

  1. QWebEngineView *webView = new QWebEngineView(parent);
  2. QWebEngineSettings *settings = webView->settings();
  3.  
  4. // 禁止加载图片
  5. settings->setAttribute(QWebEngineSettings::AutoLoadImages, false);
  6.  
  7. // 允许JavaScript执行
  8. settings->setAttribute(QWebEngineSettings::JavascriptEnabled, true);

在这个示例中，我们首先获取了QWebEngineView的设置对象，然后分别禁止了图片的自动加载，并启用了JavaScript执行。

36、void QWebEngineView::showEvent(QShowEvent *event)

void QWebEngineView::showEvent(QShowEvent *event) 是Qt WebEngine模块中QWebEngineView类的一个覆盖方法，它是对QWidget的showEvent事件进行处理的函数。当QWebEngineView组件即将变为可见状态时（即从隐藏变为显示），这个事件处理器会被调用。

通常在重写这个方法时，你可以在这里做一些在视图显示之前或者显示时需要执行的操作，比如加载网页、调整视图大小、初始化视图状态等。例如：

  1. void MyWebEngineView::showEvent(QShowEvent *event)
  2. {
  3.     // 调用父类的showEvent方法以确保默认处理得以执行
  4.     QWebEngineView::showEvent(event);
  5.  
  6.     // 在视图显示时加载一个初始网页
  7.     load(QUrl("https://www.example.com"));
  8.  
  9.     // 或者执行其他与视图显示相关的操作
  10. }

在这个示例中，当MyWebEngineView变为可见时，它会加载指定的网页地址。当然，你可以根据实际需求在这个函数中执行其他定制的操作。

37、QSize QWebEngineView::sizeHint() const

QSize QWebEngineView::sizeHint() const 是Qt WebEngine模块中QWebEngineView类的一个成员函数，它返回一个QSize对象，表示QWebEngineView组件建议的最佳大小（size hint）。

这个大小通常是由QWebEngineView内部根据其内容（如加载的网页大小）计算得出的，用于向布局管理器提供一个参考大小。布局管理器可以根据这个提示信息来更好地安排组件的布局，但最终的大小可能会因为布局约束或者其他因素而不同于这个size hint。

在实践中，如果你想要获取QWebEngineView在其内容加载完毕后的理想大小，可以调用这个函数获取。然而，具体的显示大小仍需由其父窗口或布局管理器决定。

38、void QWebEngineView::triggerPageAction(QWebEnginePage::WebAction action, bool checked = false)

void QWebEngineView::triggerPageAction(QWebEnginePage::WebAction action, bool checked = false) 是Qt WebEngine模块中QWebEngineView类的一个函数，它用于触发与给定WebAction枚举值关联的页面操作。

QWebEnginePage::WebAction是一个枚举类型，包含了多种预定义的网页操作，如打开新窗口、后退、前进、刷新、停止加载、打印等。

函数参数说明：

  • QWebEnginePage::WebAction action：指定要触发的WebAction操作，例如 QWebEnginePage::Back 表示后退，QWebEnginePage::Reload 表示刷新页面等。
  • bool checked = false：对于某些操作，如检查/取消检查复选框（例如“是否启用Java”这类设置），这个参数用于指定操作的开关状态。对于大多数WebAction而言，这个参数并不重要，但对于某些涉及状态切换的操作可能需要设置。

例如，触发页面后退操作：

webEngineView->triggerPageAction(QWebEnginePage::Back);

触发页面刷新操作：

webEngineView->triggerPageAction(QWebEnginePage::Reload);

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/寸_铁/article/detail/839028
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号