Qt+Cef3离屏渲染（一）

最新推荐文章于 2024-03-04 10:54:44 发布
原创 最新推荐文章于 2024-03-04 10:54:44 发布 · 9k 阅读 · 31 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

离屏渲染(Off-Screen Rendering)

在离屏渲染模式下，CEF不会创建原生浏览器窗口。CEF为宿主程序提供无效的区域和像素缓存区，而宿主程序负责通知鼠标键盘以及焦点事件给CEF。离屏渲染目前不支持混合加速，所以性能上可能无法和非离屏渲染相比。离屏浏览器将收到和窗口浏览器同样的事件通知，

下面介绍如何使用离屏渲染：

实现CefRenderHandler接口。除非特别说明，所有的方法都需要覆写。
调用CefWindowInfo::SetAsOffScreen()，将CefWindowInfo传递给CefBrowserHost::CreateBrowser()之前还可以选择设置CefWindowInfo::SetTransparentPainting()。

如果没有父窗口被传递给SetAsOffScreen,则有些类似上下文菜单这样的功能将不可用。

CefRenderHandler::GetViewRect方法将被调用以获得所需要的可视区域。
CefRenderHandler::OnPaint() 方法将被调用以提供无效区域（脏区域）以及更新过的像素缓存。

cefclient程序里使用OpenGL绘制缓存，但你可以使用任何别的绘制技术。

可以调用CefBrowserHost::WasResized()方法改变浏览器大小。这将导致对GetViewRect()方法的调用，以获取新的浏览器大小，然后调用OnPaint()重新绘制。

调用CefBrowserHost::SendXXX()方法通知浏览器的鼠标、键盘和焦点事件。

调用CefBrowserHost::CloseBrowser()销毁浏览器。

使用命令行参数–off-screen-rendering-enabled运行cefclient，可以测试离屏渲染的效果。

这段话是来自：https://github.com/fanfeilong/cefutil/blob/master/doc/CEF%20General%20Usage-zh-cn.md#off-screen-rendering

离屏渲染可以Qt背景透明下的显示问题，比如做一些异形窗口。

我们从一个简单的例子来实现Qt中的Cef3的离屏渲染。上面的步骤看起来有点复杂，但我们从实际的例子入手，一步步完善，就简单了。

第一步：

在CefSettings中的windowless_rendering_enabled设置为true

settings.windowless_rendering_enabled = true;

第二步：

继承CefRenderHandler，并且实现它全部接口（也就是纯虚函数），和重新部分virtual函数（是部分，可以不用全部实现，这个看你的功能需求）

  // Called to retrieve the view rectangle which is relative to screen
  // coordinates. This method must always provide a non-empty rectangle.
  ///
  /*--cef()--*/
  virtual void GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect) = 0;

  // Called when an element should be painted. Pixel values passed to this
  // method are scaled relative to view coordinates based on the value of
  // CefScreenInfo.device_scale_factor returned from GetScreenInfo. |type|
  // indicates whether the element is the view or the popup widget. |buffer|
  // contains the pixel data for the whole image. |dirtyRects| contains the set
  // of rectangles in pixel coordinates that need to be repainted. |buffer| will
  // be |width|*|height|*4 bytes in size and represents a BGRA image with an
  // upper-left origin. This method is only called when
  // CefWindowInfo::shared_texture_enabled is set to false.
  ///
  /*--cef()--*/
  virtual void OnPaint(CefRefPtr<CefBrowser> browser,
                       PaintElementType type,
                       const RectList& dirtyRects,
                       const void* buffer,
                       int width,
                       int height) = 0;

解释一下：

  virtual void GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect) = 0;

这个纯虚函数就是获取浏览器的矩形范围，想象一下，如果你想将浏览器放在某个QWidget，或者子控件上，那么这里的rect就应该返回该QWidget的矩形区域。在实际中，这个rect设置为(0, 0, width, height)。
看这里的rect的引用，其实就是要对这个rect进行赋值，剩下的就交给Cef自己去做了。

第二个函数：

 virtual void OnPaint(CefRefPtr<CefBrowser> browser,
                       PaintElementType type,
                       const RectList& dirtyRects,
                       const void* buffer,
                       int width,
                       int height) = 0;

这个就比较关键了
它就是将获取的每一帧图片的数据存放在buffer指针指向内存中，width和height是这张图片的宽和高。

这个type，根据源码其实就是

typedef enum {
  PET_VIEW = 0,
  PET_POPUP,
} cef_paint_element_type_t;

这个枚举，这个可以先不用去管它，后面再深入了解它就行，知道有这么个参数就行。

第三步：
将第二步中OnPaint中获取的图像数据，贴到QWidget所在的矩形位置上。

通过事件，将刚刚获取的图像，以QImage对象的方式，发送给窗口，在paintEvent中将这个QImage贴到界面上（调用QPainter的drawImage）

第四步：
在窗口的resizeEvent事件中调用
调用CefBrowserHost的WasResized()方法，这样窗口大小变化的时候，离屏渲染出来的图像大小也会变化，我们看到的就是“浏览器”随着窗口的尺寸变化而变化。

以上就是我自己摸索出来的最简单的离屏渲染的几个步骤，接下来的几篇博客，我会逐步添加一些响应事件，让离屏渲染的功能更加完善。万丈高楼平地起，我们一步步来。

我们从代码开始：
main.cpp中

#include "cefosrwidget.h"
#include "simple_app.h"
#include "simple_handler.h"

#include <QApplication>

void QCefInitSettings(CefSettings & settings)
{
   //std::string cache_path = AppGetWorkingDirectory().toStdString() + "/.cache";//缓存地址
   // CefString(&settings.cache_path) = CefString(cache_path);
    settings.multi_threaded_message_loop = true;//多线程消息循环
    settings.log_severity = LOGSEVERITY_DISABLE;//日志

    settings.windowless_rendering_enabled = true;

    settings.no_sandbox = false;//沙盒
}

int QCefInit(int& argc, char** argv)
{
    HINSTANCE hInstance = static_cast<HINSTANCE>(GetModuleHandle(nullptr));

    CefMainArgs mainArgs(hInstance);
    CefRefPtr<SimpleApp> app(new SimpleApp); //CefApp实现，用于处理进程相关的回调。

    int exit_code = CefExecuteProcess(mainArgs, app.get(), nullptr);
    if (exit_code >= 0) {
        return exit_code;
    }

    CefSettings settings;
    QCefInitSettings(settings);
    CefInitialize(mainArgs, settings, app, nullptr);

    return -1;
}

void CefQuit()
{
    CefShutdown();
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    int result = QCefInit(argc, argv);
    if (result >= 0) {
        return result;
    }

    CefOSRWidget widget;
    widget.show();

    a.exec();
    CefQuit();

    return 0;
}

simple_app.h

// Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.

#ifndef CEF_TESTS_CEFSIMPLE_SIMPLE_APP_H_
#define CEF_TESTS_CEFSIMPLE_SIMPLE_APP_H_

#include "include/cef_app.h"

// Implement application-level callbacks for the browser process.
class SimpleApp : public CefApp, public CefBrowserProcessHandler {
 public:
  SimpleApp();

  // CefApp methods:
  virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler()
      OVERRIDE {
    return this;
  }

  // CefBrowserProcessHandler methods:
  virtual void OnContextInitialized() OVERRIDE;

 private:
  // Include the default reference counting implementation.
  IMPLEMENT_REFCOUNTING(SimpleApp);
};

#endif  // CEF_TESTS_CEFSIMPLE_SIMPLE_APP_H_

simple_app.cc

// Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.

#include "simple_app.h"

#include <string>

#include "include/cef_browser.h"
#include "include/cef_command_line.h"
#include "include/views/cef_browser_view.h"
#include "include/views/cef_window.h"
#include "include/wrapper/cef_helpers.h"
#include "simple_handler.h"

namespace {

// When using the Views framework this object provides the delegate
// implementation for the CefWindow that hosts the Views-based browser.
class SimpleWindowDelegate : public CefWindowDelegate {
 public:
  explicit SimpleWindowDelegate(CefRefPtr<CefBrowserView> browser_view)
      : browser_view_(browser_view) {}

  void OnWindowCreated(CefRefPtr<CefWindow> window) OVERRIDE {
    // Add the browser view and show the window.
    window->AddChildView(browser_view_);
    window->Show();

    // Give keyboard focus to the browser view.
    browser_view_->RequestFocus();
  }

  void OnWindowDestroyed(CefRefPtr<CefWindow> window) OVERRIDE {
    browser_view_ = NULL;
  }

  bool CanClose(CefRefPtr<CefWindow> window) OVERRIDE {
    // Allow the window to close if the browser says it's OK.
    CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
    if (browser)
      return browser->GetHost()->TryCloseBrowser();
    return true;
  }

  CefSize GetPreferredSize(CefRefPtr<CefView> view) OVERRIDE {
    return CefSize(800, 600);
  }

 private:
  CefRefPtr<CefBrowserView> browser_view_;

  IMPLEMENT_REFCOUNTING(SimpleWindowDelegate);
  DISALLOW_COPY_AND_ASSIGN(SimpleWindowDelegate);
};

}  // namespace

SimpleApp::SimpleApp() {}

void SimpleApp::OnContextInitialized() {
  CEF_REQUIRE_UI_THREAD();

  CefRefPtr<CefCommandLine> command_line =
      CefCommandLine::GetGlobalCommandLine();

////  const bool use_transparent_painting =
////      use_windowless_rendering_ &&
//      command_line_->HasSwitch(switches::kTransparentPaintingEnabled);

#if defined(OS_WIN) || defined(OS_LINUX)
  // Create the browser using the Views framework if "--use-views" is specified
  // via the command-line. Otherwise, create the browser using the native
  // platform framework. The Views framework is currently only supported on
  // Windows and Linux.
  const bool use_views = command_line->HasSwitch("use-views");
#else
  const bool use_views = false;
#endif
}

这些和前面的例子都一样，接下来就有点不同了：
simple_handler.h

// Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.

#ifndef CEF_TESTS_CEFSIMPLE_SIMPLE_HANDLER_H_
#define CEF_TESTS_CEFSIMPLE_SIMPLE_HANDLER_H_

#include "include/cef_client.h"
#include "include/base/cef_lock.h"

#include <list>
#include <QImage>
#include <QPainter>
#include <WinUser.h>
#include <QDebug>
#include <QObject>

class SimpleHandler : public CefClient,
                      public CefLifeSpanHandler,
                      public CefLoadHandler,
                      public CefFocusHandler,
                      public CefDisplayHandler,
                      public CefRenderHandler //新加的

{
public:
  explicit SimpleHandler(bool use_views);
  ~SimpleHandler() OVERRIDE;

  void setWinHandle(HWND hwnd);
  void setReceiver(QObject *receiver);

  // Provide access to the single global instance of this object.
  static SimpleHandler* GetInstance();

  // CefClient methods:
  virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() OVERRIDE { return this; }

  virtual CefRefPtr<CefFocusHandler> GetFocusHandler() OVERRIDE { return this; }

  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE { return this; }

  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE { return this; }

  virtual CefRefPtr<CefRenderHandler> GetRenderHandler() OVERRIDE { return this; } //新加的

  // CefLifeSpanHandler methods:
  virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
  virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE;

  // CefLoadHandler methods:
  virtual void OnLoadError(CefRefPtr<CefBrowser> browser,
                           CefRefPtr<CefFrame> frame,
                           ErrorCode errorCode,
                           const CefString& errorText,
                           const CefString& failedUrl) OVERRIDE;



  // CefFocusHandler methods
//  virtual bool OnSetFocus(CefRefPtr<CefBrowser> browser, FocusSource source) OVERRIDE;

  // Request that all existing browser windows close.
  void CloseAllBrowsers(bool force_close);

  bool IsClosing() const { return is_closing_; }

  std::list<CefRefPtr<CefBrowser> > getCefBrowerList();

  //CefRenderHandler methods
  virtual void GetViewRect(CefRefPtr<CefBrowser> browser, CefRect& rect) OVERRIDE;

  virtual void OnPaint(CefRefPtr<CefBrowser> browser,
                       PaintElementType type,
                       const RectList& dirtyRects,
                       const void* buffer,
                       int width,
                       int height) OVERRIDE;

private:
  // True if the application is using the Views framework.
  const bool use_views_;

  // List of existing browser windows. Only accessed on the CEF UI thread.
  typedef std::list<CefRefPtr<CefBrowser>> BrowserList;
  BrowserList browser_list_;

  bool is_closing_;

  // True if mouse cursor change is disabled.
  bool m_bMouseCursorChangeDisabled;

  HWND m_hwnd;
  QObject *m_receiver;

  // Include the default reference counting implementation.
  IMPLEMENT_REFCOUNTING(SimpleHandler);
};

#endif  // CEF_TESTS_CEFSIMPLE_SIMPLE_HANDLER_H_

simple_handler.cc

// Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
// reserved. Use of this source code is governed by a BSD-style license that
// can be found in the LICENSE file.

#include "simple_handler.h"

#include <sstream>
#include <string>
#include <QDebug>
#include <QDateTime>
#include <QBuffer>
#include <QPixmap>
#include <QtWin>

#include <QCoreApplication>

#include "include/base/cef_bind.h"
#include "include/cef_app.h"
#include "include/views/cef_browser_view.h"
#include "include/views/cef_window.h"
#include "include/wrapper/cef_closure_task.h"
#include "include/wrapper/cef_helpers.h"
#include "events.h"

namespace {

SimpleHandler* g_instance = NULL;

}  // namespace

SimpleHandler::SimpleHandler(bool use_views)
    : use_views_(use_views), is_closing_(false) {
  DCHECK(!g_instance);
  g_instance = this;

  m_bMouseCursorChangeDisabled = false;

  m_receiver = nullptr;
}

SimpleHandler::~SimpleHandler() {
    g_instance = nullptr;
}

void SimpleHandler::setWinHandle(HWND hwnd)
{
    m_hwnd = hwnd;
}

void SimpleHandler::setReceiver(QObject *receiver)
{
    m_receiver = receiver;
}

// static
SimpleHandler* SimpleHandler::GetInstance() {
    return g_instance;
}

void SimpleHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
  CEF_REQUIRE_UI_THREAD()

  if (m_bMouseCursorChangeDisabled)
      browser->GetHost()->SetMouseCursorChangeDisabled(true);
  else
    browser->GetHost()->SetMouseCursorChangeDisabled(false);

  // Add to the list of existing browsers.
  browser_list_.push_back(browser);
}

bool SimpleHandler::DoClose(CefRefPtr<CefBrowser> browser) {
  CEF_REQUIRE_UI_THREAD()

  // Closing the main window requires special handling. See the DoClose()
  // documentation in the CEF header for a detailed destription of this
  // process.
  if (browser_list_.size() == 1) {
    // Set a flag to indicate that the window close should be allowed.
    is_closing_ = true;
  }

  // Allow the close. For windowed browsers this will result in the OS close
  // event being sent.
  return false;
}

void SimpleHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
  CEF_REQUIRE_UI_THREAD()

  // Remove from the list of existing browsers.
  BrowserList::iterator bit = browser_list_.begin();
  for (; bit != browser_list_.end(); ++bit) {
    if ((*bit)->IsSame(browser)) {
      browser_list_.erase(bit);
      break;
    }
  }

  if (browser_list_.empty()) {
    // All browser windows have closed. Quit the application message loop.
    CefQuitMessageLoop();
  }
}

void SimpleHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
                                CefRefPtr<CefFrame> frame,
                                ErrorCode errorCode,
                                const CefString& errorText,
                                const CefString& failedUrl) {
  CEF_REQUIRE_UI_THREAD()

  qDebug() << "errorCode: " << errorCode;

  // Don't display an error for downloaded files.
  if (errorCode == ERR_ABORTED)
    return;

  // Display a load error message.
  std::stringstream ss;
  ss << "<html><body bgcolor=\"white\">"
        "<h2>Failed to load URL "
     << std::string(failedUrl) << " with error " << std::string(errorText)
     << " (" << errorCode << ").</h2></body></html>";
  frame->LoadString(ss.str(), failedUrl);
}

void SimpleHandler::CloseAllBrowsers(bool force_close) {
  if (!CefCurrentlyOn(TID_UI)) {
    // Execute on the UI thread.
    CefPostTask(TID_UI, base::Bind(&SimpleHandler::CloseAllBrowsers, this,
                                   force_close));
    return;
  }

  if (browser_list_.empty())
    return;

  BrowserList::const_iterator it = browser_list_.begin();
  for (; it != browser_list_.end(); ++it)
      (*it)->GetHost()->CloseBrowser(force_close);
}

std::list<CefRefPtr<CefBrowser> > SimpleHandler::getCefBrowerList()
{
    return browser_list_;
}

void SimpleHandler::GetViewRect(CefRefPtr<CefBrowser> browser, CefRect &rect)
{
    RECT clientRect;
    if (!::GetClientRect(m_hwnd, &clientRect))
        return;

    rect.x = rect.y = 0;
    rect.width = clientRect.right;
    rect.height = clientRect.bottom;

    return;
}

void SimpleHandler::OnPaint(CefRefPtr<CefBrowser> browser,
                            CefRenderHandler::PaintElementType type,
                            const CefRenderHandler::RectList &dirtyRects,
                            const void *buffer,
                            int width,
                            int height)
{
    HBITMAP bitmap= CreateBitmap(width,height,1,32,buffer);
    QImage image = QtWin::imageFromHBITMAP(bitmap);

    if (image.isNull())
    {
        qDebug() << "image is null";
        return;
    }

    //以下为测试代码，将图片写到文件中去
    //QString fileName = QString("D:/1/%1.png").arg(QDateTime::currentMSecsSinceEpoch());
    //image.save(fileName, "PNG");

    UpdateEvent *updateEvent = new UpdateEvent(image);
    QCoreApplication::postEvent(m_receiver, updateEvent);
}

自定义事件，需要了解postEvent是在异步的，可以跨线程使用，如果不清楚，可以查阅相应资料

events.h

#ifndef EVENTS_H
#define EVENTS_H

#include <QEvent>
#include <QImage>

class UpdateEvent : public QEvent
{
public:
    const static Type eventType = static_cast<Type>(QEvent::User+1);
    explicit UpdateEvent(const QImage &image);
    QImage m_image;
};

#endif // EVENTS_H

events.cpp

#include "events.h"

UpdateEvent::UpdateEvent(const QImage &image) :QEvent(eventType)
{
    m_image = image;
}

cefosrwidget.h

#ifndef CEFOSRWIDGET_H
#define CEFOSRWIDGET_H

#include "simple_handler.h"

#include <QWidget>

QT_BEGIN_NAMESPACE
namespace Ui { class CefOSRWidget; }
QT_END_NAMESPACE

class CefOSRWidget : public QWidget
{
    Q_OBJECT

public:
    CefOSRWidget(QWidget *parent = nullptr);
    ~CefOSRWidget() override;

protected:
    void resizeEvent(QResizeEvent *event) override;

    void paintEvent(QPaintEvent *event) override;

    bool event(QEvent *event) override;

    CefRefPtr<CefBrowser> getBrowser();

private:
    Ui::CefOSRWidget *ui;

    CefRefPtr<SimpleHandler> m_browserHander;

    QImage m_image;
};
#endif // CEFOSRWIDGET_H

cefosrwidget.cpp

#include "cefosrwidget.h"
#include "ui_cefosrwidget.h"

#include "events.h"

#include <QMessageBox>
#include <QPainter>
#include <QMouseEvent>
#include <QDebug>

CefOSRWidget::CefOSRWidget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::CefOSRWidget)
{
    ui->setupUi(this);

    //Cef离屏渲染的话，设置了WA_TranslucentBackground也没有渲染问题
//    setAttribute(Qt::WA_TranslucentBackground);
//    setWindowFlags(Qt::FramelessWindowHint);

    HWND wnd = (HWND)this->winId();
    QString indexUrl = "www.baidu.com";
    //这里可以换成本地的网，加载本地网页文件，格式为：file://绝对路径中的xx.html
    //例如"file://" + QCoreApplication::applicationDirPath() + "/index.html"

    CefWindowInfo cefWndInfo;
    cefWndInfo.SetAsWindowless(wnd);

    CefBrowserSettings cefBrowSetting;
//    cefBrowSetting.background_color = 180;
    cefBrowSetting.windowless_frame_rate = 60; //设置帧率，默认值是30

    m_browserHander = CefRefPtr<SimpleHandler>(new SimpleHandler(false));
    m_browserHander->setWinHandle(wnd);
    m_browserHander->setReceiver(this);

    //注意这里是异步创建
    bool isCreated = CefBrowserHost::CreateBrowser(cefWndInfo, m_browserHander, CefString(indexUrl.toStdWString()), cefBrowSetting, nullptr, nullptr);
    if (!isCreated)
    {
        QMessageBox::information(nullptr, "warning", "brower create failed!");
    }
}

void CefOSRWidget::resizeEvent(QResizeEvent *event)
{
    QWidget::resizeEvent(event);

    CefRefPtr<CefBrowser> pBrower = getBrowser();
    if (pBrower)
    {
        pBrower->GetHost()->WasResized();
        pBrower->GetHost()->SetMouseCursorChangeDisabled(false);
    }
}

void CefOSRWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event)
    QPainter painter(this);

    QRect rect = this->rect();

//    painter.setOpacity(0.5); //这里可以改变浏览器整体的透明度，比如这里设置为0.5

    painter.drawImage(QRect(rect.left(), rect.top(), rect.width(), rect.height()), m_image, m_image.rect());
}

bool CefOSRWidget::event(QEvent *event)
{
    if (event->type() == UpdateEvent::eventType)
    {
        UpdateEvent *updateEvent = dynamic_cast<UpdateEvent*>(event);
        m_image = updateEvent->m_image;
        this->update();

        return true;
    }
    return QWidget::event(event);
}

CefRefPtr<CefBrowser> CefOSRWidget::getBrowser()
{
    if (!m_browserHander.get())
    {
        return nullptr;
    }

    std::list<CefRefPtr<CefBrowser> > cefBrowerList = m_browserHander->getCefBrowerList();
    if (cefBrowerList.size() == 0)
    {
        qDebug() << "cefBrowerList.size() == 0"; //浏览器是异步创建的，OnAfterCreated是在创建成功后调用的
        return nullptr;
    }

    return cefBrowerList.front();
}

CefOSRWidget::~CefOSRWidget()
{
    delete ui;
}

在这里插入图片描述

注意点：
在pro文件中，需要添加

LIBS += Gdi32.lib

要点讲解：
（1）离屏渲染需要继承CefRenderHandler，并且实现GetViewRect和OnPaint
（2）在OnPaint中

void SimpleHandler::OnPaint(CefRefPtr<CefBrowser> browser,
                            CefRenderHandler::PaintElementType type,
                            const CefRenderHandler::RectList &dirtyRects,
                            const void *buffer,
                            int width,
                            int height)
{
    HBITMAP bitmap= CreateBitmap(width,height,1,32,buffer);
    QImage image = QtWin::imageFromHBITMAP(bitmap);

    if (image.isNull())
    {
        qDebug() << "image is null";
        return;
    }

    //以下为测试代码，将图片写到文件中去
    //QString fileName = QString("D:/1/%1.png").arg(QDateTime::currentMSecsSinceEpoch());
    //image.save(fileName, "PNG");

    UpdateEvent *updateEvent = new UpdateEvent(image);
    QCoreApplication::postEvent(m_receiver, updateEvent);
}

使用了windows平台的API，将图形数据转成了HBITMAP格式图片，需要包含头文件

#include <QtWin>

以及在pro文件中添加

LIBS += Gdi32.lib

刚开始的时候，为了测试，将获取的图片，写到本地磁盘上，然后通过就可以知道是否获取到离屏的图片

 //以下为测试代码，将图片写到文件中去
    //QString fileName = QString("D:/1/%1.png").arg(QDateTime::currentMSecsSinceEpoch());
    //image.save(fileName, "PNG");

（3）通过Qt的postEvent发送异步事件，去通知Qt窗口更新，将获取的QImage复制一份，放到自定义事件中。

UpdateEvent *updateEvent = new UpdateEvent(image);
QCoreApplication::postEvent(m_receiver, updateEvent);

为了可以指定接收者，需要添加

 void setReceiver(QObject *receiver);

将Qt窗口的指针传递进来， 将离屏渲染得到的图片一张张发送给receiver，所以这里要指定接受者

（4）与真窗口不同的CefWindowInfo 设置：

    HWND wnd = (HWND)this->winId();
    QString indexUrl = "www.baidu.com";
    //这里可以换成本地的网，加载本地网页文件，格式为：file://绝对路径中的xx.html
    //例如"file://" + QCoreApplication::applicationDirPath() + "/index.html"

    CefWindowInfo cefWndInfo;
    cefWndInfo.SetAsWindowless(wnd);

    CefBrowserSettings cefBrowSetting;
//    cefBrowSetting.background_color = 180;
    cefBrowSetting.windowless_frame_rate = 60; //设置帧率，默认值是30

（5）
重写event事件，根据自定义的更新事件，在paintEvent中进行重绘

protected:
    bool event(QEvent *event) override;

bool CefOSRWidget::event(QEvent *event)
{
    if (event->type() == UpdateEvent::eventType)
    {
        UpdateEvent *updateEvent = dynamic_cast<UpdateEvent*>(event);
        m_image = updateEvent->m_image;
        this->update();

        return true;
    }
    return QWidget::event(event);
}

void CefOSRWidget::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event)
    QPainter painter(this);

    QRect rect = this->rect();

//    painter.setOpacity(0.5); //这里可以改变浏览器整体的透明度，比如这里设置为0.5

    painter.drawImage(QRect(rect.left(), rect.top(), rect.width(), rect.height()), m_image, m_image.rect());
}

离屏渲染，可以解决了Qt窗口中setAttribute(Qt::WA_TranslucentBackground);
背景透明时的显示问题。

在这里插入图片描述
试试将窗口设置为无边框，背景透明窗口。

本工程运行的是release版，代码放在百度云上

链接：https://pan.baidu.com/s/1XNstavzVVkTL2yq0Ee3iVg
提取码：hr13

下面是去掉了cef运行需要的资源文件（如果你看过我之前的教程，就可以下载下面的，体积更小）
链接：https://pan.baidu.com/s/1q-BxygVWCwuEWLfdpqzwKg
提取码：zfdj

接下来需要解决的问题：
（1）鼠标的点击事件
（2）滚轮事件
（3）鼠标hoved到链接上，鼠标形状的变化
（4）键盘输入
（5）输入框的右键弹出层

（这些问题会在后续说明如何处理。。。）

Qt+Cef3离屏渲染（二）
斧冰
12-19 3382
还是以windows上vs2017 release版本运行的程序为例。 接上一篇，我们只是将离屏渲染的每一帧图片QImage，以异步事件的方法发送到了目标QWiget上，然后再将QImage绘制到屏幕上。 留下了一些待处理的问题： 滚轮事件 鼠标的点击事件 鼠标hover到链接上，鼠标形状的变化 键盘输入 输入框的右键弹出层 我们这篇博客就围绕这些问题进行处理。 一、离屏渲染的滚轮事件的处理 滚轮事件的处理最为简单。 在CefOSRWidget头文件中： protected: //其余代码与前面一篇相
qt调用cef的Demo，实现js与C++之间的交互细节
最新发布
2501_91893428的博客
09-11 1127
本文提供了一个在Qt中集成CEF框架并实现JS与C++双向交互的最小可行示例。Demo包含四个关键部分：1）main.cpp初始化CEF并创建Qt窗口；2）cef_app_qt.h处理JS调用C++的交互逻辑；3）cef_browser_widget.h实现浏览器控件和C++调用JS功能；4）index.html提供前端交互界面。通过注册V8函数和ExecuteJavaScript方法，实现了JS调用C++函数（带参数和返回值）和C++调用JS函数的完整交互流程，为Qt-CEF集成开发提供了基础框架。
cef离屏渲染的例子
03-11
cef离屏渲染的c++代码示例，改自cefclient（在群里朋友的基础上修改的，更直接明了，删掉了多余的文件），有需要的朋友可以参考一下
cef3-windows-sample:Windows 上的 Chromium Embedded Framework 3 离屏渲染示例
06-16
cef3-window-sample Windows 上的离屏渲染示例。 使用 html/css3 构建 GUI 和动画。 安装 $ git clone https://github.com/teaegg/cef3-windows-sample.git 或 。 使用 vs2010+ 打开 doomtool.vcxproj。 建造 或者运行 /cef3-windows-sample/build/Release/ 中的 doomtool.exe 贡献 叉它！ 创建您的功能分支： git checkout -b my-new-feature 提交您的更改： git commit -m &#39;Add some feature&#39; 推送到分支： git push origin my-new-feature 提交拉取请求 :D 执照
离屏渲染学习笔记
qq_16379603的博客
08-11 802
一、概念理解 OpenGL中，GPU屏幕渲染有以下两种方式： On-Screen Rendering 意为当前屏幕渲染，指的是GPU的渲染操作是在当前用于显示的屏幕缓冲区中进行。 Off-Screen Rendering 意为离屏渲染，指的是GPU在当前屏幕缓冲区以外新开辟一个缓冲区进行渲染操作。 二、离屏渲染的是是非非 相比于当前屏幕渲染，离屏渲
WIN7+CEF+QT+开启离屏渲染
yuanzi_180313的博客
03-04 711
Win7环境下Cef版本应该小于104版本，因为106版本之后中文输入程序会崩溃，最终选择100版本，但是需要修改最新QCEFVIEW的一行代码。
Linux平台CEF离屏渲染
clark的专栏
01-25 4119
一、简介 Chromium 嵌入式框架 (CEF)。是一个简单的框架，用于将基于 Chromium 的浏览器嵌入到其他应用程序中。 CEF 支持广泛的编程语言和操作系统，并且可以轻松集成到新的和现有的应用程序中。它的设计从一开始就兼顾了性能和易用性。基本框架包括通过本机库公开的 C 和 C++ 编程接口，这些库将主机应用程序与 Chromium 和 Blink 实现细节隔离开来。它提供了浏览器和主机应用程序之间的紧密集成，包括对自定义插件、协议、JavaScript 对象和 JavaScript 扩展的
qt+cef嵌入浏览器
03-12
Qt是一个跨平台的C++图形用户界面库，而CEF则是一个开源项目，它允许开发者将Google Chrome的Web渲染引擎集成到他们的应用程序中。 **Qt 模块与 WebView** Qt的WebView模块是QtWebKit的一部分，它提供了一个用于...
cef-mixer：使用CEF的高性能离屏渲染（OSR）演示
02-03
`cef-mixer` 是一个基于Chromium Embedded Framework (CEF)的项目，它展示了如何实现高性能的离屏渲染（Off-Screen Rendering, OSR）。CEF是一个开源框架，允许开发者将Chromium浏览器引擎嵌入到C++应用中，用于构建...
cef离屏渲染osr示例
01-12
标题 "cef离屏渲染osr示例" 涉及的是CEF（Chromium Embedded Framework）的一个特定功能，即离屏渲染（Off-Screen Rendering，OSR）。CEF是基于Google Chrome浏览器内核的开源框架，允许开发者在自己的应用程序中...
qt调用cef编译的库版本的浏览器作者臧传凯_浏览器_CEF_qt+cef_QT_QTCEF_
09-30
总的来说，QT调用CEF编译的库版本的浏览器是一种高效且灵活的解决方案，能够利用QT的强大GUI功能和CEF的现代Web渲染能力，为桌面应用提供高度定制化的网页浏览体验。通过深入研究和实践，开发者可以进一步提升其在...
cef离屏渲染osr示例-lq20190604.zip
06-04
CEF透明背景，摘抄的某位大神的代码，然后修改了一下。
cef for qt
06-15
基于vs2010，cef_binary_3.2171.1979_windows32，qt5.1写的，请将cef的Debug及Release文件夹拷贝到本源码include的同级目录，然后将dll文件拷贝到exe同级目录。
cef离屏渲染（osr）初识
testcpp的博客
06-12 6575
cef离屏渲染（osr）初识 业务需要，客户端的webview需要使用使用osr,透明绘制，才能实现一些业务，于是有了这个经历，如果你是新手，不妨看看。 环境配置 先下一个cef官方的demo,如果找不到请：点它 我下载的是这个 我的环境是win+vs2019所以我需要生成一个vs工程， 这是我解压后的目录，一看显然可以用cmake生成vs工程 于是 如图，我是vs2019,下载是32位的，如此选择操作；于是工程就有了 打开工程： ceflient是一个五脏俱全的例子，所以选择它作为启动项，编译运行起
linux CEF 离屏渲染详解
qq_41145567的博客
04-02 4925
Linux CEF 离屏渲染详解 1.下载linux版本的cef源码 下载地址：https://cef-builds.spotifycdn.com/index.html 下载对应的源码  tar -xjvf 文件名.tar.bz2 // 解压到当前文件夹 2. 编译cef 1、自行安装cmake make gcc g++ gdb等 工具 2、首先 cmake 编译 cef文件夹内的CMakeLists.txt 文件生成 MakeFile 文件 3、再用
libcef-框架架构中概念介绍-离屏渲染-发布任务-进程间通信 (IPC)-异步 JavaScript 绑定（五）
插件开发
03-19 1753
文章目录1.离屏渲染2.发布任务3.进程间通信 (IPC)3.1 进程启动消息3.2 运行时处理消息4.异步 JavaScript 绑定4.1 通用消息路由器4.2 自定义实现5.同步请求6.作者答疑 1.离屏渲染   使用离屏渲染 CEF 不会创建本机浏览器窗口。相反，CEF 为主机应用程序提供无效区域和像素缓冲区，主机应用程序将鼠标、键盘和焦点事件通知 CEF。离屏渲染目前不支持加速合成，因此与窗口浏览器相比，性能可能会受到影响。屏幕外浏览器将收到与窗口浏览器相同的通知，包括上一节中描述的生命周期通知。
cef利用off-screen-rendering离屏渲染进行视频录像
我是榜样的博客
01-05 7623
##windows客户端如果是通过cef来实现的，那么可以通过osr模式来进行视频录像。 ##cef off-screen rendering介绍 cef的off-screen rendering功能，可以把需要渲染的图像数据，以回调的方式回调给我们，由我们自己来绘制。 比如使用opengl绘制纹理。 我们可以利用这个数据来进行客户端的屏幕录像。 ##开启离屏渲染功能 ###一、修改CefSett...
菜鸟与 cef 的邂逅之旅（四）：Soui 离屏渲染封装 Cef3 细节分析
热门推荐
(ÒωÓױ)
08-12 1万+
一、引言最近因为项目组涉及到了 Cef3 的任务，临时来学习，经过了两个周的时间，加上各位大神和 Demo 的帮助，已经有了一点点感悟，希望在自己尚未遗忘之际，详细的记录下来，以飨各位同样在 Cef3 初学之际迷惘的人。这篇博客的背景，是我已经成功编译运行了蓝先生（Soui 界面群里面的一位对我帮助很大的大神）的 Demo，这个 Demo 里已经集成了这篇博客里所有要讲述的内容。但是我并不满足于现成
掌握qt+cef实现多层网页点击访问
3. 谷歌内核：指的是CEF底层使用的Chromium浏览器的核心，Chromium基于谷歌开发的开源项目，它使用了谷歌自己的V8 JavaScript引擎和Blink渲染引擎。 关于“压缩包子文件的文件名称列表：release”，这部分信息似乎...
评论 19
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值