initial commit

Author: tishion

.clang-format

@@ -0,0 +1,8 @@
+---
+BasedOnStyle: Mozilla
+ColumnLimit: 120
+AlignAfterOpenBracket: Align
+BinPackArguments: false
+SortIncludes: false
+FixNamespaceComments: true # add commend at end:
+NamespaceIndentation: None #intend content of namespace

.editorconfig

@@ -0,0 +1,8 @@
+# To learn more about .editorconfig see https://aka.ms/editorconfigdocs
+
+# All files
+[*.{c,cpp,cxx,h,hpp,hxx}]
+indent_style = space
+charset = utf-8-bom
+insert_final_newline = true
+trim_trailing_whitespace = true

.gitignore

@@ -0,0 +1,3 @@
+.build.*
+dep/cef
+output

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "CefViewCore"]
+	path = CefViewCore
+	url = https://github.com/CefView/CefViewCore

CMakeLists.txt

@@ -0,0 +1,88 @@
+# 
+# The main config file for QCefView
+#
+cmake_minimum_required(VERSION 3.4.1)
+project(QCefView)
+
+# Only generate Debug and Release configuration types.
+set(CMAKE_CONFIGURATION_TYPES Debug Release)
+# Set proejct architecture
+set(PROJECT_ARCH x86_64)
+
+# Use folders in the resulting project files.
+set_property(GLOBAL PROPERTY OS_FOLDERS ON)
+
+# C standard
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_STANDARD 11)
+
+# C++ standard
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_STANDARD 11)
+
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
+  set(OS_MACOS 1)
+  set(OS_POSIX 1)
+  add_definitions(-DOS_MACOS=1 -DOS_POSIX=1)
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+  set(OS_LINUX 1)
+  set(OS_POSIX 1)
+  add_definitions(-DOS_LINUX=1 -DOS_POSIX=1)
+elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
+  set(OS_WINDOWS 1)
+  add_definitions(-DOS_WINDOWS=1)
+endif()
+
+# Config the QT package
+###############################################################
+set(QT_SDK_DIR "$ENV{QTDIR}")
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${QT_SDK_DIR})
+###############################################################
+
+# Config the CEF
+###############################################################
+# Disable the sandbox
+if ((NOT DEFINED USE_SANDBOX) OR (USE_SANDBOX STREQUAL "") 
+    OR (${USE_SANDBOX} MATCHES "(FALSE|false|0|OFF)"))
+    option(USE_SANDBOX "Enable CEF Sandbox" OFF)
+elseif(${USE_SANDBOX} MATCHES "(TRUE|true|1|null|ON)")
+    option(USE_SANDBOX "Enable CEF Sandbox" ON)
+else()
+    message(FATAL_ERROR "++++++++++ INVALID FLAG USE_SANDBOX=" ${USE_SANDBOX})
+endif()
+###############################################################
+
+if (OS_WINDOWS)
+  add_link_options(/DEBUG)
+endif()
+
+if (OS_MACOS)
+  set(CMAKE_OSX_DEPLOYMENT_TARGET 10.9)
+endif()
+
+set(CMAKE_SUPPRESS_REGENERATION TRUE)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/output/$<CONFIG>/bin)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/output/$<CONFIG>/bin)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/output/$<CONFIG>/lib)
+
+# Include CefViewCore
+add_subdirectory(CefViewCore)
+
+# Config QCefView target
+###############################################################
+add_subdirectory(src)
+
+# Config the Demo project
+###############################################################
+if ((NOT DEFINED BUILD_DEMO) OR (BUILD_DEMO STREQUAL "") 
+    OR (${BUILD_DEMO} MATCHES "(FALSE|false|0|OFF)"))
+    option(BUILD_DEMO "Build the demo" OFF)
+elseif(${BUILD_DEMO} MATCHES "(TRUE|true|1|null|ON)")
+    option(BUILD_DEMO "Build the demo" ON)
+else()
+    message(FATAL_ERROR "++++++++++ INVALID FLAG BUILD_DEMO=" ${BUILD_DEMO})
+endif()
+if (BUILD_DEMO)
+  add_subdirectory(test/QCefViewTest)
+endif()
+###############################################################

CefViewCore

@@ -0,0 +1 @@
+cmake -G "Xcode" -S . -B .build.mac -DBUILD_DEMO=ON -DUSE_SANDBOX=ON

generate-mac-proj.sh

@@ -0,0 +1 @@
+cmake -G "Visual Studio 16 2019" -A Win32 -S . -B .build.win -DBUILD_DEMO=ON

generate-win-proj.bat

@@ -0,0 +1,65 @@
+#ifndef QCEFEVENT_H
+#define QCEFEVENT_H
+#pragma once
+#include <QCefView_global.h>
+
+#pragma region qt_headers
+#include <QObject>
+#include <QString>
+#pragma endregion qt_headers
+
+/// <summary>
+///
+/// </summary>
+class QCEFVIEW_EXPORT QCefEvent : public QObject
+{
+  Q_OBJECT
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+  QCefEvent();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="name"></param>
+  QCefEvent(const QString& name);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="name"></param>
+  void setEventName(const QString& name);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="key"></param>
+  /// <param name="value"></param>
+  void setIntProperty(const QString& key, int value);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="key"></param>
+  /// <param name="value"></param>
+  void setDoubleProperty(const QString& key, double value);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="key"></param>
+  /// <param name="value"></param>
+  void setStringProperty(const QString& key, const QString& value);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="key"></param>
+  /// <param name="value"></param>
+  void setBoolProperty(const QString& key, bool value);
+};
+
+#endif // QCEFEVENT_H

include/QCefEvent.h

@@ -0,0 +1,126 @@
+#ifndef QCEFQUERY_H
+#define QCEFQUERY_H
+#pragma once
+#include <QCefView_global.h>
+
+#pragma region std_headers
+#include <cstdint>
+#pragma endregion std_headers
+
+#pragma region qt_headers
+#include <QString>
+#include <QPointer>
+#include <QMetaType>
+#pragma endregion qt_headers
+
+/// <summary>
+///
+/// </summary>
+class QCEFVIEW_EXPORT QCefQuery : public QObject
+{
+  Q_OBJECT
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+  QCefQuery();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="req"></param>
+  /// <param name="query"></param>
+  QCefQuery(const QString& req, const int64_t query);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="other"></param>
+  QCefQuery(const QCefQuery& other);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="other"></param>
+  /// <returns></returns>
+  QCefQuery& operator=(const QCefQuery& other);
+
+  /// <summary>
+  ///
+  /// </summary>
+  ~QCefQuery();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  const QString reqeust() const;
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  const int64_t id() const;
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  const QString response() const;
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  const bool result() const;
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  const int error() const;
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="success"></param>
+  /// <param name="response"></param>
+  /// <param name="error"></param>
+  void setResponseResult(bool success, const QString& response, int error = 0) const;
+
+private:
+  /// <summary>
+  ///
+  /// </summary>
+  int64_t id_;
+
+  /// <summary>
+  ///
+  /// </summary>
+  QString reqeust_;
+
+  /// <summary>
+  ///
+  /// </summary>
+  mutable QString response_;
+
+  /// <summary>
+  ///
+  /// </summary>
+  mutable bool restult_;
+
+  /// <summary>
+  ///
+  /// </summary>
+  mutable int error_;
+
+  ///// <summary>
+  /////
+  ///// </summary>
+  // static int TYPEID;
+};
+
+// Q_DECLARE_METATYPE(QCefQuery);
+
+#endif // QCEFQUERY_H

include/QCefQuery.h

@@ -0,0 +1,176 @@
+#ifndef QCEFSETTINGS_H
+#define QCEFSETTINGS_H
+#pragma once
+#include <QCefView_global.h>
+
+#pragma region qt_headers
+#include <QString>
+#include <QMetaType>
+#pragma endregion qt_headers
+
+namespace QCefSetting {
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setBrowserSubProcessPath(const QString& path);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+browserSubProcessPath();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setResourceDirectoryPath(const QString& path);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+resourceDirectoryPath();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setLocalesDirectoryPath(const QString& path);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+localesDirectoryPath();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setUserAgent(const QString& agent);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+userAgent();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setCachePath(const QString& path);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+cachePath();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setUserDataPath(const QString& path);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+userDataPath();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setBridgeObjectName(const QString& name);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+bridgeObjectName();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setPersistSessionCookies(bool enabled);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT bool
+persistSessionCookies();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setPersistUserPreferences(bool enabled);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT bool
+persistUserPreferences();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setLocale(const QString& locale);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+locale();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setRemoteDebuggingPort(int port);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT int
+remoteDebuggingPort();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setBackgroundColor(const QColor& color);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QColor
+backgroundColor();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setAcceptLanguageList(const QString& languages);
+
+/// <summary>
+///
+/// </summary>
+const QCEFVIEW_EXPORT QString
+acceptLanguageList();
+
+/// <summary>
+///
+/// </summary>
+void QCEFVIEW_EXPORT
+setGlobalCookie(const QString& name, const QString& value, const QString& domain, const QString& url);
+
+}; // namespace QCefSetting
+
+#endif

include/QCefSetting.h

@@ -0,0 +1,309 @@
+#ifndef QCEFVIEW_H
+#define QCEFVIEW_H
+#pragma once
+#include <QCefView_global.h>
+
+#pragma region std_headers
+#include <memory>
+#pragma endregion std_headers
+
+#pragma region qt_headers
+#include <QWidget>
+#include <QVariantList>
+#pragma endregion qt_headers
+
+#include <QCefQuery.h>
+#include <QCefEvent.h>
+
+/** Outline of QCefView:
+ **
+ **		+--------------------------------------------------------------+
+ **		| QCefView(QWidget)                                            |
+ **		|                                                              |
+ **		|    +----------------------------------------------------+    |
+ **		|    | WindowWrapper(QWidget)                             |    |
+ **		|    |                                                    |    |
+ **		|    |    +-------------------------------------------+   |    |
+ **		|    |    | CefWindow(QWindow)                        |   |    |
+ **		|    |    |                                           |   |    |
+ **		|    |    |                                           |   |    |
+ **		|    |    |                                           |   |    |
+ **		|    |    +-------------------------------------------+   |    |
+ **		|    |                                                    |    |
+ **		|    +----------------------------------------------------+    |
+ **		|                                                              |
+ **		+--------------------------------------------------------------+
+ **
+ **	Remarks:
+ **		The WindowWrapper and CefWindow are transparent to upper layer user.
+ **
+ **/
+
+class CefContextMenuHandler;
+class CefDialogHandler;
+class CefDisplayHandler;
+class CefDownloadHandler;
+class CefJSDialogHandler;
+class CefKeyboardHandler;
+
+/// <summary>
+///
+/// </summary>
+class QCEFVIEW_EXPORT QCefView : public QWidget
+{
+  /// <summary>
+  ///
+  /// </summary>
+  Q_OBJECT
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+  QCefView(const QString url, QWidget* parent = 0);
+
+  /// <summary>
+  ///
+  /// </summary>
+  QCefView(QWidget* parent = 0);
+
+  /// <summary>
+  ///
+  /// </summary>
+  ~QCefView();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="path"></param>
+  /// <param name="url"></param>
+  static void addLocalFolderResource(const QString& path, const QString& url, int priority = 0);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="path"></param>
+  /// <param name="url"></param>
+  /// <param name="password"></param>
+  static void addArchiveResource(const QString& path, const QString& url, const QString& password = "");
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="name"></param>
+  /// <param name="value"></param>
+  /// <param name="domain"></param>
+  /// <param name="url"></param>
+  void addCookie(const QString& name, const QString& value, const QString& domain, const QString& url);
+
+  /// <summary>
+  /// Navigates to the content.
+  /// </summary>
+  /// <param name="content"></param>
+  void navigateToString(const QString& content);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="url"></param>
+  void navigateToUrl(const QString& url);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  bool browserCanGoBack();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  bool browserCanGoForward();
+
+  /// <summary>
+  ///
+  /// </summary>
+  void browserGoBack();
+
+  /// <summary>
+  ///
+  /// </summary>
+  void browserGoForward();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  bool browserIsLoading();
+
+  /// <summary>
+  ///
+  /// </summary>
+  void browserReload();
+
+  /// <summary>
+  ///
+  /// </summary>
+  void browserStopLoad();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="name"></param>
+  /// <param name="event"></param>
+  /// <param name="frameId"></param>
+  /// <returns></returns>
+  bool triggerEvent(const QCefEvent& event);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="name"></param>
+  /// <param name="event"></param>
+  /// <param name="frameId"></param>
+  /// <returns></returns>
+  bool triggerEvent(const QCefEvent& event, int frameId);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="name"></param>
+  /// <param name="event"></param>
+  /// <returns></returns>
+  bool broadcastEvent(const QCefEvent& event);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="query"></param>
+  /// <returns></returns>
+  bool responseQCefQuery(const QCefQuery& query);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="handler"></param>
+  void setContextMenuHandler(CefContextMenuHandler* handler);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="handler"></param>
+  void setDialogHandler(CefDialogHandler* handler);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="handler"></param>
+  void setDisplayHandler(CefDisplayHandler* handler);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="handler"></param>
+  void setDownloadHandler(CefDownloadHandler* handler);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="handler"></param>
+  void setJSDialogHandler(CefJSDialogHandler* handler);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="handler"></param>
+  void setKeyboardHandler(CefKeyboardHandler* handler);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="isLoading"></param>
+  /// <param name="canGoBack"></param>
+  /// <param name="canGoForward"></param>
+  virtual void onLoadingStateChanged(bool isLoading, bool canGoBack, bool canGoForward);
+
+  /// <summary>
+  ///
+  /// </summary>
+  virtual void onLoadStart();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="httpStatusCode"></param>
+  virtual void onLoadEnd(int httpStatusCode);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="errorCode"></param>
+  /// <param name="errorMsg"></param>
+  /// <param name="failedUrl"></param>
+  /// <param name="handled"></param>
+  virtual void onLoadError(int errorCode, const QString& errorMsg, const QString& failedUrl, bool& handled);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="region"></param>
+  virtual void onDraggableRegionChanged(const QRegion& region);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="message"></param>
+  /// <param name="level"></param>
+  virtual void onConsoleMessage(const QString& message, int level);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="next"></param>
+  virtual void onTakeFocus(bool next);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="url"></param>
+  virtual void onQCefUrlRequest(const QString& url);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="query"></param>
+  virtual void onQCefQueryRequest(const QCefQuery& query);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="browserId"></param>
+  /// <param name="frameId"></param>
+  /// <param name="method"></param>
+  /// <param name="arguments"></param>
+  virtual void onInvokeMethodNotify(int browserId, int frameId, const QString& method, const QVariantList& arguments);
+
+protected:
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="event"></param>
+  virtual void changeEvent(QEvent* event) override;
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="watched"></param>
+  /// <param name="event"></param>
+  /// <returns></returns>
+  virtual bool eventFilter(QObject* watched, QEvent* event) override;
+
+private:
+  /// <summary>
+  ///
+  /// </summary>
+  class Implementation;
+  std::unique_ptr<Implementation> pImpl_;
+};
+
+#endif // QCEFVIEW_H

include/QCefView.h

@@ -0,0 +1,18 @@
+#ifndef QCEFEVIEW_GLOBAL_H
+#define QCEFEVIEW_GLOBAL_H
+#pragma once
+
+#pragma region qt_headers
+#include <QtCore/qglobal.h>
+#pragma endregion qt_headers
+
+#ifdef QCEFVIEW_LIB
+#define QCEFVIEW_EXPORT Q_DECL_EXPORT
+#else
+#define QCEFVIEW_EXPORT Q_DECL_IMPORT
+#if _WIN32
+#pragma comment(lib, "QCefView.lib")
+#endif
+#endif
+
+#endif // QCEFEVIEW_GLOBAL_H

include/QCefView_global.h

@@ -0,0 +1,118 @@
+### QCefView 
+################################################################################################
+set(CMAKE_GLOBAL_AUTOGEN_TARGET OFF)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+find_package(Qt5 COMPONENTS Core GUI Widgets REQUIRED)
+
+file(GLOB_RECURSE QCefView_INCLUDE_FILES
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include/*.h"
+)
+source_group(
+  TREE "${CMAKE_CURRENT_SOURCE_DIR}/../include"
+  PREFIX Include 
+  FILES ${QCefView_INCLUDE_FILES}
+)
+
+file(GLOB_RECURSE QCefView_SRC_FILES
+  "${CMAKE_CURRENT_SOURCE_DIR}/*.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
+)
+source_group(
+  TREE ${CMAKE_CURRENT_SOURCE_DIR} 
+  PREFIX Source 
+  FILES ${QCefView_SRC_FILES}
+)
+
+if (OS_WINDOWS)
+  file(GLOB_RECURSE QCefView_windows_SRC_FILES
+    "${CMAKE_CURRENT_SOURCE_DIR}/win/*.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/win/*.cpp"
+  )
+  source_group(
+    TREE "${CMAKE_CURRENT_SOURCE_DIR}/win" 
+    PREFIX Source 
+    FILES ${QCefView_windows_SRC_FILES}
+  )
+
+  add_library(QCefView SHARED
+    ${QCefView_INCLUDE_FILES}
+    ${QCefView_SRC_FILES}
+    ${QCefView_windows_SRC_FILES}
+  )
+
+  target_compile_definitions(QCefView PRIVATE
+    UNICODE
+    _UNICODE
+    QCEFVIEW_LIB
+  )
+endif()  # OS_WINDOWS
+
+if (OS_MACOS)
+  file(GLOB_RECURSE QCefView_macOS_SRC_FILES
+    "${CMAKE_CURRENT_SOURCE_DIR}/mac/*.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/mac/*.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/mac/*.mm"
+  )
+  source_group(
+    TREE "${CMAKE_CURRENT_SOURCE_DIR}/mac" 
+    PREFIX Source 
+    FILES ${QCefView_macOS_SRC_FILES}
+  )
+  set(QCefView_INFO_PLIST_FILE "${CMAKE_CURRENT_LIST_DIR}/mac/Info.plist")
+
+  add_library(QCefView SHARED
+    ${QCefView_INCLUDE_FILES}
+    ${QCefView_SRC_FILES}
+    ${QCefView_macOS_SRC_FILES}
+    ${QCefView_INFO_PLIST_FILE}
+  )
+
+  set_target_properties(QCefView
+    PROPERTIES
+      FRAMEWORK TRUE
+      COMPILE_FLAGS                                               "-fobjc-arc"
+      PUBLIC_HEADER                                               "${PerduCef_PUBLIC_HEADERS}"
+      MACOSX_FRAMEWORK_INFO_PLIST                                 "${PerduCef_INFO_PLIST_FILE}"
+      MACOSX_FRAMEWORK_IDENTIFIER                                 "com.perducef.perducefview"
+      CLANG_ENABLE_OBJC_ARC                                       "YES"
+      XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD                 "gnu++11"     # -std=gnu++11
+      XCODE_ATTRIBUTE_CLANG_LINK_OBJC_RUNTIME                     "NO"          # -fno-objc-link-runtime
+      XCODE_ATTRIBUTE_COPY_PHASE_STRIP                            "NO"
+      XCODE_ATTRIBUTE_DEAD_CODE_STRIPPING[variant=Release]        "YES"         # -Wl,-dead_strip
+      XCODE_ATTRIBUTE_GCC_C_LANGUAGE_STANDARD                     "c99"         # -std=c99
+  )
+
+  add_custom_command(
+    TARGET QCefView
+    PRE_BUILD
+
+    #copy the cef framework to resource directory
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+    "$<TARGET_BUNDLE_DIR:QCefView>/../Chromium Embedded Framework.framework"
+    "$<TARGET_FILE_DIR:QCefView>/Resources/Chromium Embedded Framework.framework"
+
+    #copy the cef framework to resource directory
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+    "$<TARGET_BUNDLE_DIR:QCefView>/../CefViewWing.app"
+    "$<TARGET_FILE_DIR:QCefView>/Resources/CefViewWing.app"
+    VERBATIM
+  )
+endif()  # OS_MACOS
+
+target_include_directories(QCefView PRIVATE
+  "${CMAKE_CURRENT_SOURCE_DIR}/../include"
+  ${CefViewCore_EXPORT_INCLUDE_PATH}
+)
+
+add_dependencies(QCefView
+  CefViewCore
+)
+
+target_link_libraries(QCefView PRIVATE
+  Qt5::Core
+  Qt5::Gui 
+  Qt5::Widgets
+  CefViewCore
+)
+

src/CMakeLists.txt

@@ -0,0 +1,54 @@
+#include <QCefEvent.h>
+
+#pragma region qt_headers
+#include <QVariant>
+#pragma endregion qt_headers
+
+#pragma region cef_headers
+#include <include/cef_app.h>
+#include <include/wrapper/cef_message_router.h>
+#pragma endregion cef_headers
+
+QCefEvent::QCefEvent()
+  : QObject(nullptr)
+{}
+
+QCefEvent::QCefEvent(const QString& name)
+  : QObject()
+{
+  setObjectName(name);
+}
+
+void
+QCefEvent::setEventName(const QString& name)
+{
+  setObjectName(name);
+}
+
+void
+QCefEvent::setIntProperty(const QString& key, int value)
+{
+  Q_ASSERT(0 != QString::compare(key, "name", Qt::CaseInsensitive));
+  setProperty(key.toUtf8().constData(), QVariant::fromValue(value));
+}
+
+void
+QCefEvent::setDoubleProperty(const QString& key, double value)
+{
+  Q_ASSERT(0 != QString::compare(key, "name", Qt::CaseInsensitive));
+  setProperty(key.toUtf8().constData(), QVariant::fromValue(value));
+}
+
+void
+QCefEvent::setStringProperty(const QString& key, const QString& value)
+{
+  Q_ASSERT(0 != QString::compare(key, "name", Qt::CaseInsensitive));
+  setProperty(key.toUtf8().constData(), QVariant::fromValue(value));
+}
+
+void
+QCefEvent::setBoolProperty(const QString& key, bool value)
+{
+  Q_ASSERT(0 != QString::compare(key, "name", Qt::CaseInsensitive));
+  setProperty(key.toUtf8().constData(), QVariant::fromValue(value));
+}

src/QCefEvent.cpp

@@ -0,0 +1,83 @@
+#include <QCefQuery.h>
+
+#pragma region cef_headers
+#include <include/cef_app.h>
+#include <include/wrapper/cef_message_router.h>
+#pragma endregion cef_headers
+
+#include <QCefView.h>
+
+// int QCefQuery::TYPEID = qRegisterMetaType<QCefQuery>("QCefQuery");
+
+//////////////////////////////////////////////////////////////////////////
+
+QCefQuery::QCefQuery()
+  : id_(-1)
+  , restult_(false)
+  , error_(0)
+{}
+
+QCefQuery::QCefQuery(const QString& req, const int64_t query)
+  : reqeust_(req)
+  , id_(query)
+  , restult_(false)
+  , error_(0)
+{}
+
+QCefQuery::QCefQuery(const QCefQuery& other)
+{
+  reqeust_ = other.reqeust_;
+  id_ = other.id_;
+  restult_ = other.restult_;
+  response_ = other.response_;
+}
+
+QCefQuery&
+QCefQuery::operator=(const QCefQuery& other)
+{
+  reqeust_ = other.reqeust_;
+  id_ = other.id_;
+  restult_ = other.restult_;
+  response_ = other.response_;
+  return *this;
+}
+
+QCefQuery::~QCefQuery() {}
+
+const QString
+QCefQuery::reqeust() const
+{
+  return reqeust_;
+}
+
+const int64_t
+QCefQuery::id() const
+{
+  return id_;
+}
+
+const QString
+QCefQuery::response() const
+{
+  return response_;
+}
+
+const bool
+QCefQuery::result() const
+{
+  return restult_;
+}
+
+const int
+QCefQuery::error() const
+{
+  return error_;
+}
+
+void
+QCefQuery::setResponseResult(bool success, const QString& response, int error /*= 0*/) const
+{
+  restult_ = success;
+  response_ = response;
+  error_ = error;
+}

src/QCefQuery.cpp

@@ -0,0 +1,197 @@
+#include "QCefSetting.h"
+
+#pragma region qt_headers
+#include <QColor.h>
+#pragma endregion qt_headers
+
+#include "details/CCefSetting.h"
+
+void
+QCefSetting::setBrowserSubProcessPath(const QString& path)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::browser_sub_process_path.FromString(path.toStdString());
+}
+
+const QString
+QCefSetting::browserSubProcessPath()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::browser_sub_process_path.ToString());
+}
+
+void
+QCefSetting::setResourceDirectoryPath(const QString& path)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::resource_directory_path.FromString(path.toStdString());
+}
+
+const QString
+QCefSetting::resourceDirectoryPath()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::resource_directory_path.ToString());
+}
+
+void
+QCefSetting::setLocalesDirectoryPath(const QString& path)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::locales_directory_path.FromString(path.toStdString());
+}
+
+const QString
+QCefSetting::localesDirectoryPath()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::locales_directory_path.ToString());
+}
+
+void
+QCefSetting::setUserAgent(const QString& agent)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::user_agent.FromString(agent.toStdString());
+}
+
+const QString
+QCefSetting::userAgent()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::user_agent.ToString());
+}
+
+void
+QCefSetting::setCachePath(const QString& path)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::cache_path.FromString(path.toStdString());
+}
+
+const QString
+QCefSetting::cachePath()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::cache_path.ToString());
+}
+
+void
+QCefSetting::setUserDataPath(const QString& path)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::user_data_path.FromString(path.toStdString());
+}
+
+const QString
+QCefSetting::userDataPath()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::user_data_path.ToString());
+}
+
+void
+QCefSetting::setBridgeObjectName(const QString& name)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::bridge_object_name.FromString(name.toStdString());
+}
+
+const QString
+QCefSetting::bridgeObjectName()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::bridge_object_name);
+}
+
+void
+QCefSetting::setPersistSessionCookies(bool enabled)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::persist_session_cookies = enabled ? true : false;
+}
+
+const bool
+QCefSetting::persistSessionCookies()
+{
+  CCefSetting::initializeInstance();
+  return CCefSetting::persist_session_cookies ? true : false;
+}
+
+void
+QCefSetting::setPersistUserPreferences(bool enabled)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::persist_user_preferences = enabled ? true : false;
+}
+
+const bool
+QCefSetting::persistUserPreferences()
+{
+  CCefSetting::initializeInstance();
+  return CCefSetting::persist_user_preferences ? true : false;
+}
+
+void
+QCefSetting::setLocale(const QString& locale)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::locale.FromString(locale.toStdString());
+}
+
+const QString
+QCefSetting::locale()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::locale.ToString());
+}
+
+void
+QCefSetting::setRemoteDebuggingPort(int port)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::remote_debugging_port = port;
+}
+
+const int
+QCefSetting::remoteDebuggingPort()
+{
+  CCefSetting::initializeInstance();
+  return CCefSetting::remote_debugging_port;
+}
+
+void
+QCefSetting::setBackgroundColor(const QColor& color)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::background_color = static_cast<cef_color_t>(color.rgba());
+}
+
+const QColor
+QCefSetting::backgroundColor()
+{
+  CCefSetting::initializeInstance();
+  return QColor::fromRgba(static_cast<QRgb>(CCefSetting::background_color));
+}
+
+void
+QCefSetting::setAcceptLanguageList(const QString& languages)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::accept_language_list.FromString(languages.toStdString());
+}
+
+const QString
+QCefSetting::acceptLanguageList()
+{
+  CCefSetting::initializeInstance();
+  return QString::fromStdString(CCefSetting::accept_language_list.ToString());
+}
+
+void QCEFVIEW_EXPORT
+QCefSetting::setGlobalCookie(const QString& name, const QString& value, const QString& domain, const QString& url)
+{
+  CCefSetting::initializeInstance();
+  CCefSetting::global_cookie_list.push_back(
+    { name.toStdString(), value.toStdString(), domain.toStdString(), url.toStdString() });
+}

src/QCefSetting.cpp

@@ -0,0 +1,137 @@
+#include "CCefDelegate.h"
+
+CCefDelegate::CCefDelegate(QCefView* view, QCefWindow* window)
+  : view_(view)
+  , window_(window)
+{}
+
+void
+CCefDelegate::setCefBrowserWindowHandle(CefWindowHandle win)
+{
+  if (window_)
+    window_->setCefBrowserWindow(win);
+}
+
+void
+CCefDelegate::loadingStateChanged(bool isLoading, bool canGoBack, bool canGoForward)
+{
+  if (view_)
+    view_->onLoadingStateChanged(isLoading, canGoBack, canGoForward);
+}
+
+void
+CCefDelegate::loadStart()
+{
+  if (view_)
+    view_->onLoadStart();
+}
+
+void
+CCefDelegate::loadEnd(int httpStatusCode)
+{
+  if (view_)
+    view_->onLoadEnd(httpStatusCode);
+}
+
+void
+CCefDelegate::loadError(int errorCode, const std::string& errorMsg, const std::string& failedUrl, bool& handled)
+{
+  if (view_) {
+    auto msg = QString::fromStdString(errorMsg);
+    auto url = QString::fromStdString(failedUrl);
+    view_->onLoadError(errorCode, msg, url, handled);
+  }
+}
+
+void
+CCefDelegate::draggableRegionChanged(const std::vector<CefDraggableRegion>& regions)
+{
+  if (view_) {
+    // Determine new draggable region.
+    QRegion region;
+    std::vector<CefDraggableRegion>::const_iterator it = regions.begin();
+    for (; it != regions.end(); ++it) {
+      region += QRegion(it->bounds.x, it->bounds.y, it->bounds.width, it->bounds.height);
+    }
+    view_->onDraggableRegionChanged(region);
+  }
+}
+
+void
+CCefDelegate::consoleMessage(const std::string& message, int level)
+{
+  if (view_) {
+    auto msg = QString::fromStdString(message);
+    view_->onConsoleMessage(msg, level);
+  }
+}
+
+void
+CCefDelegate::takeFocus(bool next)
+{
+  if (view_)
+    view_->onTakeFocus(next);
+}
+
+void
+CCefDelegate::processUrlRequest(const std::string& url)
+{
+  if (view_) {
+    auto u = QString::fromStdString(url);
+    view_->onQCefUrlRequest(u);
+  }
+}
+
+void
+CCefDelegate::processQueryRequest(const std::string& request, const int64_t query_id)
+{
+  if (view_) {
+    auto req = QString::fromStdString(request);
+    view_->onQCefQueryRequest(QCefQuery(req, query_id));
+  }
+}
+
+void
+CCefDelegate::invokeMethodNotify(int browserId,
+                                 int frameId,
+                                 const std::string& method,
+                                 const CefRefPtr<CefListValue>& arguments)
+{
+  if (!view_)
+    return;
+
+  auto m = QString::fromStdString(method);
+
+  QVariantList argumentList;
+  QString qStr;
+  for (int idx = 0; idx < arguments->GetSize(); idx++) {
+    if (CefValueType::VTYPE_NULL == arguments->GetType(idx))
+      argumentList.push_back(0);
+    else if (CefValueType::VTYPE_BOOL == arguments->GetType(idx))
+      argumentList.push_back(QVariant::fromValue(arguments->GetBool(idx)));
+    else if (CefValueType::VTYPE_INT == arguments->GetType(idx))
+      argumentList.push_back(QVariant::fromValue(arguments->GetInt(idx)));
+    else if (CefValueType::VTYPE_DOUBLE == arguments->GetType(idx))
+      argumentList.push_back(QVariant::fromValue(arguments->GetDouble(idx)));
+    else if (CefValueType::VTYPE_STRING == arguments->GetType(idx)) {
+#if defined(CEF_STRING_TYPE_UTF16)
+      qStr = QString::fromUtf16((char16_t*)arguments->GetString(idx).c_str());
+#elif defined(CEF_STRING_TYPE_UTF8)
+      qStr = QString::fromUtf8(arguments->GetString(idx).c_str());
+#elif defined(CEF_STRING_TYPE_WIDE)
+      qStr = QString::fromWCharArray(arguments->GetString(idx).c_str());
+#endif
+      argumentList.push_back(qStr);
+    } else {
+      // invalid type
+    }
+  }
+
+  view_->onInvokeMethodNotify(browserId, frameId, m, argumentList);
+}
+
+void
+CCefDelegate::browserIsDestroying()
+{
+  return;
+}

src/QCefView.cpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#pragma region qt_headers
+#include <QWindow>
+#include <QPointer>
+#include <QVariant>
+#include <QHash>
+#include <QMutex>
+#include <QRegion>
+#pragma endregion qt_headers
+
+#pragma region std_headers
+#include <memory>
+#pragma endregion std_headers
+
+#pragma region cef_headers
+#include <include/cef_app.h>
+#pragma endregion cef_headers
+
+#include <CefViewBrowserDelegate.h>
+
+#include <QCefQuery.h>
+#include <QCefView.h>
+
+#include "QCefWindow.h"
+
+class CCefDelegate
+  : public CefViewBrowserDelegateInterface
+  , public std::enable_shared_from_this<CCefDelegate>
+{
+public:
+  explicit CCefDelegate(QCefView* view, QCefWindow* window);
+
+  virtual void setCefBrowserWindowHandle(CefWindowHandle win) override;
+
+  virtual void loadingStateChanged(bool isLoading, bool canGoBack, bool canGoForward) override;
+
+  virtual void loadStart() override;
+
+  virtual void loadEnd(int httpStatusCode) override;
+
+  virtual void loadError(int errorCode,
+                         const std::string& errorMsg,
+                         const std::string& failedUrl,
+                         bool& handled) override;
+
+  virtual void draggableRegionChanged(const std::vector<CefDraggableRegion>& regions) override;
+
+  virtual void consoleMessage(const std::string& message, int level) override;
+
+  virtual void takeFocus(bool next) override;
+
+  virtual void processUrlRequest(const std::string& url) override;
+
+  virtual void processQueryRequest(const std::string& query, const int64_t query_id) override;
+
+  virtual void invokeMethodNotify(int browserId,
+                                  int frameId,
+                                  const std::string& method,
+                                  const CefRefPtr<CefListValue>& arguments) override;
+
+  virtual void browserIsDestroying() override;
+
+private:
+  QCefView* view_;
+  QCefWindow* window_;
+};

src/details/CCefDelegate.cpp

@@ -0,0 +1,102 @@
+#include "CCefManager.h"
+
+#include "CCefSetting.h"
+
+CCefManager::CCefManager()
+{
+  nBrowserRefCount_ = 0;
+}
+
+CCefManager&
+CCefManager::getInstance()
+{
+  static CCefManager s_instance;
+  return s_instance;
+}
+
+void
+CCefManager::initializeCef()
+{
+  // This is not the first time initialization
+  if (++nBrowserRefCount_ > 1)
+    return;
+
+  // Enable High-DPI support on Windows 7 or newer.
+  CefEnableHighDPISupport();
+
+  // This is the first time initialization
+  CCefSetting::initializeInstance();
+
+  CefString(&cef_settings_.browser_subprocess_path) = CCefSetting::browser_sub_process_path;
+  CefString(&cef_settings_.resources_dir_path) = CCefSetting::resource_directory_path;
+  CefString(&cef_settings_.locales_dir_path) = CCefSetting::locales_directory_path;
+  CefString(&cef_settings_.user_agent) = CCefSetting::user_agent;
+  CefString(&cef_settings_.cache_path) = CCefSetting::cache_path;
+  CefString(&cef_settings_.user_data_path) = CCefSetting::user_data_path;
+  CefString(&cef_settings_.locale) = CCefSetting::locale;
+  CefString(&cef_settings_.accept_language_list) = CCefSetting::accept_language_list;
+
+  cef_settings_.persist_session_cookies = CCefSetting::persist_session_cookies;
+  cef_settings_.persist_user_preferences = CCefSetting::persist_user_preferences;
+  cef_settings_.remote_debugging_port = CCefSetting::remote_debugging_port;
+  cef_settings_.background_color = CCefSetting::background_color;
+  cef_settings_.no_sandbox = true;
+  cef_settings_.pack_loading_disabled = false;
+  cef_settings_.multi_threaded_message_loop = true;
+
+#ifndef NDEBUG
+  cef_settings_.log_severity = LOGSEVERITY_DEFAULT;
+  cef_settings_.remote_debugging_port = CCefSetting::remote_debugging_port;
+#else
+  cef_settings_.log_severity = LOGSEVERITY_DISABLE;
+#endif
+
+  app_ = new CefViewBrowserApp(CCefSetting::bridge_object_name);
+
+#if defined(OS_WINDOWS)
+  HINSTANCE hInstance = ::GetModuleHandle(nullptr);
+  CefMainArgs main_args(hInstance);
+#else
+  CefMainArgs main_args;
+#endif
+
+  // Initialize CEF.
+  void* sandboxInfo = nullptr;
+  if (!CefInitialize(main_args, cef_settings_, app_, sandboxInfo))
+    assert(0);
+}
+
+bool
+CCefManager::addCookie(const std::string& name,
+                       const std::string& value,
+                       const std::string& domain,
+                       const std::string& url)
+{
+  CefCookie cookie;
+  CefString(&cookie.name).FromString(name);
+  CefString(&cookie.value).FromString(value);
+  CefString(&cookie.domain).FromString(domain);
+  return CefCookieManager::GetGlobalManager(nullptr)->SetCookie(CefString(url), cookie, nullptr);
+}
+
+void
+CCefManager::uninitializeCef()
+{
+  // This is not the last time release
+  if (--nBrowserRefCount_ > 0)
+    return;
+
+  // Destroy the application
+  app_ = nullptr;
+
+  // The last time release
+  // TO-DO (sheen) when we reach here, it is possible there are pending
+  // IO requests, and they will fire the DCHECK when complete or aborted
+  releaseCef();
+}
+
+void
+CCefManager::releaseCef()
+{
+  CefShutdown();
+}

src/details/CCefDelegate.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#pragma region std_headers
+#include <mutex>
+#pragma endregion std_headers
+
+#include <CefViewBrowserApp.h>
+
+/// <summary>
+///
+/// </summary>
+class CCefManager
+{
+
+protected:
+  /// <summary>
+  ///
+  /// </summary>
+  CCefManager();
+
+  /// <summary>
+  ///
+  /// </summary>
+  ~CCefManager(){};
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+  /// <returns></returns>
+  static CCefManager& getInstance();
+
+  /// <summary>
+  ///
+  /// </summary>
+  void initializeCef();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="name"></param>
+  /// <param name="value"></param>
+  /// <param name="domain"></param>
+  /// <param name="url"></param>
+  /// <returns></returns>
+  bool addCookie(const std::string& name, const std::string& value, const std::string& domain, const std::string& url);
+
+  /// <summary>
+  ///
+  /// </summary>
+  void uninitializeCef();
+
+protected:
+  /// <summary>
+  ///
+  /// </summary>
+  void releaseCef();
+
+private:
+  /// <summary>
+  ///
+  /// </summary>
+  CefRefPtr<CefViewBrowserApp> app_;
+
+  /// <summary>
+  ///
+  /// </summary>
+  CefSettings cef_settings_;
+
+  /// <summary>
+  ///
+  /// </summary>
+  int64_t nBrowserRefCount_;
+};

src/details/CCefManager.cpp

@@ -0,0 +1,42 @@
+#include "CCefSetting.h"
+
+#pragma region qt_headers
+#include <QCoreApplication>
+#include <QDir>
+#pragma endregion qt_headers
+
+#include <CefViewCoreProtocol.h>
+
+CefString CCefSetting::bridge_object_name;
+
+CefString CCefSetting::browser_sub_process_path;
+
+CefString CCefSetting::resource_directory_path;
+
+CefString CCefSetting::locales_directory_path;
+
+CefString CCefSetting::user_agent;
+
+CefString CCefSetting::cache_path;
+
+CefString CCefSetting::user_data_path;
+
+int CCefSetting::persist_session_cookies;
+
+int CCefSetting::persist_user_preferences;
+
+CefString CCefSetting::locale;
+
+int CCefSetting::remote_debugging_port = 9999;
+
+cef_color_t CCefSetting::background_color;
+
+CefString CCefSetting::accept_language_list;
+
+std::list<CCefSetting::CookieItem> CCefSetting::global_cookie_list;
+
+void
+CCefSetting::initializeInstance()
+{
+  static CCefSetting s_instance;
+}

src/details/CCefManager.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#pragma region stl_headers
+#include <list>
+#pragma endregion stl_headers
+
+#pragma region cef_headers
+#include <include/cef_base.h>
+#pragma endregion cef_headers
+
+/// <summary>
+///
+/// </summary>
+class CCefSetting
+{
+protected:
+  /// <summary>
+  ///
+  /// </summary>
+  CCefSetting();
+
+  /// <summary>
+  ///
+  /// </summary>
+  ~CCefSetting(){};
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+  static void initializeInstance();
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString bridge_object_name;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString browser_sub_process_path;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString resource_directory_path;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString locales_directory_path;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString user_agent;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString cache_path;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString user_data_path;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static int persist_session_cookies;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static int persist_user_preferences;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString locale;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static int remote_debugging_port;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static cef_color_t background_color;
+
+  /// <summary>
+  ///
+  /// </summary>
+  static CefString accept_language_list;
+
+  /// <summary>
+  ///
+  /// </summary>
+  typedef struct CookieItem
+  {
+    std::string name;
+    std::string value;
+    std::string domain;
+    std::string url;
+  } CookieItem;
+  static std::list<CookieItem> global_cookie_list;
+};

src/details/CCefSetting.cpp

@@ -0,0 +1,62 @@
+#include "QCefWindow.h"
+
+#pragma region qt_headers
+#include <QCoreApplication>
+#include <QResizeEvent>
+#include <QPaintDevice>
+#include <QPainter>
+#include <QDebug>
+#pragma endregion qt_headers
+
+#include "CCefManager.h"
+
+QCefWindow::QCefWindow(QWindow* parent, QCefView* hostView /*= 0*/)
+  : QWindow(parent)
+  , hwndCefBrowser_(nullptr)
+{
+  setFlags(Qt::FramelessWindowHint);
+
+  CCefManager::getInstance().initializeCef();
+}
+
+QCefWindow::~QCefWindow()
+{
+  if (hwndCefBrowser_)
+    hwndCefBrowser_ = nullptr;
+
+  CCefManager::getInstance().uninitializeCef();
+}
+
+void
+QCefWindow::setCefBrowserWindow(CefWindowHandle win)
+{
+  hwndCefBrowser_ = win;
+  syncCefBrowserWindow();
+}
+
+void
+QCefWindow::syncCefBrowserWindow()
+{
+#if defined(OS_WINDOWS)
+  double w = width() * devicePixelRatio();
+  double h = height() * devicePixelRatio();
+  if (hwndCefBrowser_)
+    ::SetWindowPos(hwndCefBrowser_, NULL, 0, 0, ceil(w), ceil(h), SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_DEFERERASE);
+#else
+  return;
+#endif
+}
+
+void
+QCefWindow::exposeEvent(QExposeEvent* e)
+{
+  syncCefBrowserWindow();
+  QWindow::exposeEvent(e);
+}
+
+void
+QCefWindow::resizeEvent(QResizeEvent* e)
+{
+  syncCefBrowserWindow();
+  QWindow::resizeEvent(e);
+}

src/details/CCefSetting.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#pragma region qt_headers
+#include <QWindow>
+#include <QPointer>
+#include <QVariant>
+#include <QHash>
+#include <QMutex>
+#include <QRegion>
+#pragma endregion qt_headers
+
+#pragma region cef_headers
+#include <include/cef_app.h>
+#pragma endregion cef_headers
+
+#include <CefViewBrowserDelegate.h>
+
+#include <QCefQuery.h>
+#include <QCefView.h>
+
+/// <summary>
+///
+/// </summary>
+class QCefWindow : public QWindow
+{
+  Q_OBJECT
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+
+public:
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="parent"></param>
+  explicit QCefWindow(QWindow* parent, QCefView* hostView = 0);
+
+  /// <summary>
+  ///
+  /// </summary>
+  ~QCefWindow();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="win"></param>
+  void setCefBrowserWindow(CefWindowHandle win);
+
+protected:
+  /// <summary>
+  ///
+  /// </summary>
+  void syncCefBrowserWindow();
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="e"></param>
+  virtual void exposeEvent(QExposeEvent* e);
+
+  /// <summary>
+  ///
+  /// </summary>
+  /// <param name="e"></param>
+  virtual void resizeEvent(QResizeEvent* e);
+
+private:
+  /// <summary>
+  ///
+  /// </summary>
+  CefWindowHandle hwndCefBrowser_;
+};

src/details/QCefWindow.cpp

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.cefview.qcefview</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSMinimumSystemVersion</key>
+	<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright © 2020 CefView. All rights reserved.</string>
+	<key>LSUIElement</key>
+	<string>1</string>
+	<key>LSFileQuarantineEnabled</key>
+	<true/>
+	<key>NSSupportsAutomaticGraphicsSwitching</key>
+	<true/>
+</dict>
+</plist>

src/details/QCefWindow.h

@@ -0,0 +1,24 @@
+#include "details/CCefSetting.h"
+
+#pragma region qt_headers
+#include <QCoreApplication>
+#include <QDir>
+#pragma endregion qt_headers
+
+#include <CefViewCoreProtocol.h>
+
+CCefSetting::CCefSetting()
+{
+  user_agent.FromString(CEFVIEW_USER_AGENT);
+  
+  QDir currentDir = QDir::current();
+
+  QString renderExecutablePath = currentDir.filePath(RENDER_PROCESS_NAME ".exe");
+  browser_sub_process_path.FromString(QDir::toNativeSeparators(renderExecutablePath).toStdString());
+
+  QString resourceFolderPath = currentDir.filePath(RESOURCE_DIRECTORY_NAME);
+  resource_directory_path.FromString(QDir::toNativeSeparators(resourceFolderPath).toStdString());
+
+  QString localeFolderPath = resourceFolderPath.filePath(LOCALES_DIRECTORY_NAME);
+  locales_directory_path.FromString(QDir::toNativeSeparators(localeFolderPath).toStdString());
+}

src/mac/Info.plist

@@ -0,0 +1,24 @@
+#include "details/CCefSetting.h"
+
+#pragma region qt_headers
+#include <QCoreApplication>
+#include <QDir>
+#pragma endregion qt_headers
+
+#include <CefViewCoreProtocol.h>
+
+CCefSetting::CCefSetting()
+{
+  user_agent.FromString(CEFVIEW_USER_AGENT);
+
+  QDir ExeDir = QCoreApplication::applicationDirPath();
+
+  QString strExePath = ExeDir.filePath(RENDER_PROCESS_NAME);
+  browser_sub_process_path.FromString(QDir::toNativeSeparators(strExePath).toStdString());
+
+  QString strResPath = ExeDir.filePath(RESOURCE_DIRECTORY_NAME);
+  resource_directory_path.FromString(QDir::toNativeSeparators(strResPath).toStdString());
+
+  QDir ResPath(strResPath);
+  locales_directory_path.FromString(QDir::toNativeSeparators(ResPath.filePath(LOCALES_DIRECTORY_NAME)).toStdString());
+}

src/mac/details/CCefSetting_mac.mm

@@ -0,0 +1,117 @@
+cmake_minimum_required(VERSION 3.4.1)
+project(QCefViewTest)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+find_package(Qt5 COMPONENTS Core GUI Widgets REQUIRED)
+
+get_target_property(_qmake_executable Qt5::qmake IMPORTED_LOCATION)
+get_filename_component(_qt_bin_dir "${_qmake_executable}" DIRECTORY)
+
+if (OS_WINDOWS)
+  find_program(DEPLOYQT_EXECUTABLE windeployqt HINTS "${_qt_bin_dir}")
+elseif (OS_MACOS)
+  find_program(DEPLOYQT_EXECUTABLE macdeployqt HINTS "${_qt_bin_dir}")
+elseif (OS_LINUX)
+else ()
+endif()
+
+include_directories(
+  ${CMAKE_SOURCE_DIR}/include
+)
+
+file(GLOB_RECURSE _SRC_FILES
+  "*.h"
+  "*.cpp"
+)
+
+file(GLOB_RECURSE _UI_FILES
+  "*.ui"
+)
+source_group("Form Files" ${_UI_FILES})
+
+if (OS_WINDOWS)
+  file(GLOB_RECURSE _RES_FILES
+    "*.qrc"
+    "*.rc"
+  )
+  source_group("Resource Files" ${_RES_FILES})
+
+  add_executable(${PROJECT_NAME} WIN32 
+    ${_SRC_FILES}
+    ${_UI_FILES}
+    ${_RES_FILES}
+  )
+
+  target_compile_definitions(${PROJECT_NAME} PRIVATE
+    UNICODE
+    _UNICODE
+  )
+
+  set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    PROPERTY 
+      VS_STARTUP_PROJECT ${PROJECT_NAME}
+  )
+
+  set_property(TARGET ${PROJECT_NAME} 
+    PROPERTY
+      FOLDER "Test"
+      VS_DEBUGGER_WORKING_DIRECTORY "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
+  )
+
+  add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+    # Embed the manifest file into the target
+    COMMAND mt.exe -manifest \"${CMAKE_CURRENT_SOURCE_DIR}\\${PROJECT_NAME}.manifest\" -inputresource:\"$<TARGET_FILE:${PROJECT_NAME}>\" -outputresource:\"$<TARGET_FILE:${PROJECT_NAME}>\"
+    # Copy the TEST HTML file
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/QCefViewTestPage.html $<TARGET_FILE_DIR:${PROJECT_NAME}>
+    # Deploy the Qt Application
+    COMMAND ${DEPLOYQT_EXECUTABLE} 
+    --no-svg 
+    --no-translations 
+    --no-compiler-runtime 
+    $<TARGET_FILE:${PROJECT_NAME}>
+  )
+endif()
+
+if (OS_MACOS)
+  file(GLOB_RECURSE _RES_FILES
+    "*.qrc"
+  )
+  source_group("Resource Files" ${_RES_FILES})
+
+  add_executable(${PROJECT_NAME} MACOSX_BUNDLE 
+    ${_SRC_FILES}
+    ${_UI_FILES}
+    ${_RES_FILES}
+  )
+
+  set_property(TARGET ${PROJECT_NAME} 
+    PROPERTY
+      FOLDER "Test"
+  )
+
+  add_custom_command(TARGET ${PROJECT_NAME} PRE_BUILD
+    # Copy the TEST HTML file
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    "${CMAKE_CURRENT_SOURCE_DIR}/QCefViewTestPage.html" 
+    "$<TARGET_BUNDLE_CONTENT_DIR:${PROJECT_NAME}>/Resources/QCefViewTestPage.html"
+  )
+
+  add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+    # Deploy the Qt Application
+    COMMAND ${DEPLOYQT_EXECUTABLE} 
+      $<TARGET_BUNDLE_DIR:${PROJECT_NAME}> 
+      -codesign="-"
+
+  )
+endif()
+
+target_link_libraries(${PROJECT_NAME} PUBLIC
+	Qt5::Core
+	Qt5::Gui 
+  Qt5::Widgets
+  QCefView
+)

src/win/details/CCefSetting_win.cpp

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
+    <description>QCefViewTest Applicatoin</description>
+    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+        <security>
+            <requestedPrivileges> 
+                <requestedExecutionLevel
+                    level="asInvoker"
+                    uiAccess="false"
+                />   
+            </requestedPrivileges>
+        </security>
+    </trustInfo>
+    <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1"> 
+        <application> 
+            <!-- Windows 10 --> 
+            <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
+            <!-- Windows 8.1 -->
+            <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
+            <!-- Windows Vista -->
+            <supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/> 
+            <!-- Windows 7 -->
+            <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
+            <!-- Windows 8 -->
+            <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
+        </application> 
+    </compatibility>
+</assembly>

test/QCefViewTest/CMakeLists.txt

@@ -0,0 +1,138 @@
+<html>
+
+<head>
+    <script>
+        function onColorChanged(event) {
+            var kvlist = [];
+            for (var key in event) {
+                kvlist.push(key + ":" + event[key])
+            }
+            alert(kvlist.join('\n'));
+
+            document.getElementById("main").style.backgroundColor = event["color"];
+        }
+
+        function onLoad() {
+            if (typeof (CallBridge) == 'undefined') {
+                return;
+            }
+
+            CallBridge.addEventListener("colorChange", function (event) {
+                var kvlist = [];
+                for (var key in event) {
+                    kvlist.push(key + ":" + event[key])
+                }
+                //alert(kvlist.join('\n'));
+
+                document.getElementById("main").style.backgroundColor = event["color"];
+            })
+        }
+
+        function onDragAreaMouseDown() {
+            CallBridge.invokeMethod("onDragAreaMouseDown");
+        }
+
+        function onInvokeMethodClicked() {
+            CallBridge.invokeMethod("TestMethod", 1, false, "arg3");
+        }
+
+        function onCallBridgeQueryClicked() {
+            var query = {
+                request: document.getElementById("message").value,
+                onSuccess: function (response) {
+                    alert(response);
+                },
+                onFailure: function (error_code, error_message) {
+                    alert(error_message);
+                }
+            }
+            window.CefViewQuery(query);
+        }
+
+
+        /**
+         * getFuntionName()
+         * @param {Function} func
+         * @return {String}
+         */
+        function getFunctionName(func) {
+            if (typeof func == 'function' || typeof func == 'object') {
+                var name = ('' + func).match(/function\s*([\w\$]*)\s*\(/);
+            }
+            return name && name[1];
+        }
+        /**
+         * trace
+         * @param [int] [count=10]
+         * @return {String}
+         */
+        trace = function () {
+            var stack = [],
+                caller = arguments.callee.caller;
+
+            while (caller) {
+                stack.unshift(getFunctionName(caller));
+                caller = caller && caller.caller;
+            }
+            return 'functions on stack:' + '\n' + stack.join('\n');
+        }
+
+        function OpenPopup() {
+            var popup = window.open("", "PopupWindow", "width=800, height=600");
+            popup.document.write("<p>This is popup window.</p>");
+        }
+    </script>
+    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.js"></script>
+    <style>
+        .noselect {
+            user-select: none;
+            /* Non-prefixed version, currently supported by Chrome, Edge, Opera and Firefox */
+        }
+    </style>
+</head>
+
+<body onload="onLoad()" id="main" class="noselect">
+    <h1 align="center" style="font-size:12pt; font-family:MS Shell Dlg 2;">Web Area</h1>
+    <div id="firstVue">
+        <input type="number" v-model.number="my_step" />
+        <button v-on:click="clickButton">Add</button>
+        <p>{{my_total}}</p>
+    </div>
+    <div align="center">
+        <div style="background-color:green; -webkit-app-region:drag;" onmousedown="onDragAreaMouseDown()">
+            <h1>Dragging area</h1>
+        </div>
+        <br />
+
+        <label> Test Case for InvokeMethod </label>
+        <br />
+        <input type="button" value="Invoke Method" onclick="onInvokeMethodClicked()" />
+        <br />
+        <br />
+
+        <label> Test Case for QCefQuery </label>
+        <br />
+        <textarea id="message"
+            style="width:320px; height:120px;">this message will be processed by native code.</textarea>
+        <br />
+        <input type="button" value="Query" onclick="onCallBridgeQueryClicked()" />
+        <br />
+        <br />
+    </div>
+</body>
+<script type="text/javascript">
+    var myVue = new Vue({
+        el: '#firstVue',
+        data: {
+            my_step: 1,
+            my_total: 0
+        },
+        methods: {
+            clickButton: function () {
+                this.my_total = this.my_total + this.my_step
+            }
+        }
+    })
+</script>
+
+</html>

test/QCefViewTest/QCefViewTest.manifest

@@ -0,0 +1,94 @@
+#if defined(OS_WINDOWS)
+#include <windows.h>
+#else
+#endif
+
+#include <QMessageBox>
+#include <QColor>
+#include <QRandomGenerator>
+
+#include "customcefview.h"
+
+CustomCefView::~CustomCefView() {}
+
+void
+CustomCefView::changeColor()
+{
+  QColor color(QRandomGenerator::global()->generate());
+
+  QCefEvent event("colorChange");
+  event.setStringProperty("color", color.name());
+  broadcastEvent(event);
+}
+
+void
+CustomCefView::onDraggableRegionChanged(const QRegion& region)
+{}
+
+void
+CustomCefView::onQCefUrlRequest(const QString& url)
+{
+  QMetaObject::invokeMethod(
+    this,
+    [=]() {
+      QString title("QCef URL Request");
+      QString text = QString("Current Thread: QT_UI\r\n"
+                             "URL: %1")
+                       .arg(url);
+
+      QMessageBox::information(this->window(), title, text);
+    },
+    Qt::QueuedConnection);
+}
+
+void
+CustomCefView::onQCefQueryRequest(const QCefQuery& query)
+{
+  QMetaObject::invokeMethod(
+    this,
+    [=]() {
+      QString title("QCef Query Request");
+      QString text = QString("Current Thread: QT_UI\r\n"
+                             "Query: %1")
+                       .arg(query.reqeust());
+
+      QMessageBox::information(this->window(), title, text);
+
+      QString response = query.reqeust().toUpper();
+      query.setResponseResult(true, response);
+      responseQCefQuery(query);
+    },
+    Qt::QueuedConnection);
+}
+
+void
+CustomCefView::onInvokeMethodNotify(int browserId, int frameId, const QString& method, const QVariantList& arguments)
+{
+  if (0 == method.compare("onDragAreaMouseDown")) {
+#if defined(OS_WINDOWS)
+    HWND hWnd = ::GetAncestor((HWND)(this->window()->winId()), GA_ROOT);
+    // get current mouse cursor position
+    POINT pt;
+    ::GetCursorPos(&pt);
+    // in case the mouse is being captured, try to release it
+    ::ReleaseCapture();
+    // simulate that the mouse left button is down on the title area
+    ::SendMessage(hWnd, WM_NCLBUTTONDOWN, HTCAPTION, POINTTOPOINTS(pt));
+#endif
+    return;
+  } else if (0 == method.compare("TestMethod")) {
+    QMetaObject::invokeMethod(
+      this,
+      [=]() {
+        QString title("QCef InvokeMethod Notify");
+        QString text = QString("Current Thread: QT_UI\r\n"
+                               "Method: %1\r\n"
+                               "Arguments: ...")
+                         .arg(method);
+
+        QMessageBox::information(this->window(), title, text);
+      },
+      Qt::QueuedConnection);
+  } else {
+  }
+}

test/QCefViewTest/QCefViewTestPage.html

@@ -0,0 +1,31 @@
+#ifndef CUSTOMCEFVIEW_H
+#define CUSTOMCEFVIEW_H
+
+#include <QCefView.h>
+
+class CustomCefView : public QCefView
+{
+  Q_OBJECT
+
+public:
+  using QCefView::QCefView;
+  ~CustomCefView();
+
+  void changeColor();
+
+protected:
+  virtual void onDraggableRegionChanged(const QRegion& region) override;
+
+  virtual void onQCefUrlRequest(const QString& url) override;
+
+  virtual void onQCefQueryRequest(const QCefQuery& query) override;
+
+  virtual void onInvokeMethodNotify(int browserId,
+                                    int frameId,
+                                    const QString& method,
+                                    const QVariantList& arguments) override;
+
+private:
+};
+
+#endif // CUSTOMCEFVIEW_H

test/QCefViewTest/customcefview.cpp

@@ -0,0 +1,11 @@
+#include "qcefviewtest.h"
+#include <QtWidgets/QApplication>
+
+int
+main(int argc, char* argv[])
+{
+  QApplication a(argc, argv);
+  QCefViewTest w;
+  w.show();
+  return a.exec();
+}

test/QCefViewTest/customcefview.h

@@ -0,0 +1,38 @@
+#include "qcefviewtest.h"
+
+#include <QDir>
+#include <QCoreApplication>
+#include <QHBoxLayout>
+
+#include <QCefSetting.h>
+
+QCefViewTest::QCefViewTest(QWidget* parent)
+  : QMainWindow(parent)
+{
+  ui.setupUi(this);
+  QHBoxLayout* layout = new QHBoxLayout();
+  layout->setContentsMargins(2, 2, 2, 2);
+  layout->setSpacing(3);
+
+  connect(ui.btn_changeColor, SIGNAL(clicked()), this, SLOT(onBtnChangeColorClicked()));
+  layout->addWidget(ui.nativeContainer);
+
+  QCefSetting::setBridgeObjectName("CallBridge");
+
+  QDir dir = QCoreApplication::applicationDirPath();
+  QString uri = QDir::toNativeSeparators(dir.filePath("QCefViewTestPage.html"));
+  cefview = new CustomCefView(uri, this);
+  // cefview = new CustomCefView("http://www.google.com/", this);
+  ui.cefContainer->layout()->addWidget(cefview);
+  layout->addWidget(ui.cefContainer);
+
+  centralWidget()->setLayout(layout);
+}
+
+QCefViewTest::~QCefViewTest() {}
+
+void
+QCefViewTest::onBtnChangeColorClicked()
+{
+  cefview->changeColor();
+}

test/QCefViewTest/main.cpp

@@ -0,0 +1,23 @@
+#ifndef QCEFVIEWTEST_H
+#define QCEFVIEWTEST_H
+
+#include <QtWidgets/QMainWindow>
+#include "ui_qcefviewtest.h"
+#include "customcefview.h"
+
+class QCefViewTest : public QMainWindow
+{
+	Q_OBJECT
+
+public:
+	QCefViewTest(QWidget *parent = 0);
+	~QCefViewTest();
+
+protected slots:
+	void onBtnChangeColorClicked();
+private:
+	Ui::QCefViewTestClass ui;
+	CustomCefView* cefview;
+};
+
+#endif // QCEFVIEWTEST_H

test/QCefViewTest/qcefviewtest.cpp

@@ -0,0 +1,4 @@
+<RCC>
+    <qresource prefix="QCefViewTest">
+    </qresource>
+</RCC>

test/QCefViewTest/qcefviewtest.h

@@ -0,0 +1,146 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QCefViewTestClass</class>
+ <widget class="QMainWindow" name="QCefViewTestClass">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>600</width>
+    <height>400</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>QCefViewTest</string>
+  </property>
+  <widget class="QWidget" name="centralWidget">
+   <property name="styleSheet">
+    <string notr="true">#centralWidget {
+background-color: rgb(0, 85, 0);
+}</string>
+   </property>
+   <widget class="QWidget" name="nativeContainer" native="true">
+    <property name="geometry">
+     <rect>
+      <x>20</x>
+      <y>19</y>
+      <width>120</width>
+      <height>361</height>
+     </rect>
+    </property>
+    <property name="sizePolicy">
+     <sizepolicy hsizetype="Fixed" vsizetype="Preferred">
+      <horstretch>0</horstretch>
+      <verstretch>0</verstretch>
+     </sizepolicy>
+    </property>
+    <property name="minimumSize">
+     <size>
+      <width>120</width>
+      <height>0</height>
+     </size>
+    </property>
+    <property name="maximumSize">
+     <size>
+      <width>120</width>
+      <height>16777215</height>
+     </size>
+    </property>
+    <property name="styleSheet">
+     <string notr="true">#nativeContainer {
+	background-color: rgb(170, 255, 255);
+}</string>
+    </property>
+    <layout class="QVBoxLayout" name="verticalLayout_nativeContainer">
+     <property name="spacing">
+      <number>6</number>
+     </property>
+     <property name="leftMargin">
+      <number>0</number>
+     </property>
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <property name="rightMargin">
+      <number>0</number>
+     </property>
+     <property name="bottomMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="styleSheet">
+        <string notr="true">#label{
+	font: 12pt &quot;MS Shell Dlg 2&quot;;
+}</string>
+       </property>
+       <property name="text">
+        <string>Native Area</string>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignCenter</set>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="btn_changeColor">
+       <property name="text">
+        <string>ChangeColor</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="verticalSpacer">
+       <property name="orientation">
+        <enum>Qt::Vertical</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>20</width>
+         <height>40</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+    </layout>
+   </widget>
+   <widget class="QWidget" name="cefContainer" native="true">
+    <property name="geometry">
+     <rect>
+      <x>230</x>
+      <y>20</y>
+      <width>331</width>
+      <height>351</height>
+     </rect>
+    </property>
+    <property name="styleSheet">
+     <string notr="true">#cefContainer {
+background-color: rgb(85, 170, 255);
+}</string>
+    </property>
+    <layout class="QVBoxLayout" name="verticalLayout_cefContainer">
+     <property name="spacing">
+      <number>0</number>
+     </property>
+     <property name="leftMargin">
+      <number>0</number>
+     </property>
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <property name="rightMargin">
+      <number>0</number>
+     </property>
+     <property name="bottomMargin">
+      <number>0</number>
+     </property>
+    </layout>
+   </widget>
+  </widget>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources>
+  <include location="qcefviewtest.qrc"/>
+ </resources>
+ <connections/>
+</ui>