Cef chromium mingw windows
First install some necessary tools and download the cef-project source code.
1. Install CMake, a cross-platform open-source build system. Version 2.8.12.1 or newer is required.
2. Install Python. Version 2.7.x is required. If Python is not installed to the default location you can set the PYTHON_EXECUTABLE environment variable before running CMake (watch for errors during the CMake generation step below).
3. Install platform-specific build tools.
- Linux: Currently supported distributions include Debian Wheezy, Ubuntu Precise, and related. Ubuntu 18.04 64-bit is recommended. Newer versions will likely also work but may not have been tested. Required packages include: build-essential, libgtk2.0-dev, libgtkglext1-dev.
- MacOS: Xcode 8 or newer building on MacOS 10.11 (El Capitan) or newer for x86_64. Xcode 12.2 or newer building on MacOS 10.15.4 (Catalina) or newer for ARM64. The Xcode command-line tools must also be installed. Only 64-bit builds are supported on macOS.
- Windows: Visual Studio 2015 Update 2 or newer building on Windows 7 or newer. Visual Studio 2019 and Windows 10 64-bit are recommended.
4. Download the cef-project source code from the Downloads page or by using Git command-line tools:
Now run CMake which will download the CEF binary distribution from the Spotify automated builder and generate build files for your platform. Then build using platform build tools. For example, using the most recent tool versions on each platform:
CMake supports different generators on each platform. Run cmake —help to list all supported generators. Generators that have been tested with CEF include:
- Linux: Ninja, Unix Makefiles
- MacOS: Ninja, Xcode 8+ (x86_64) or Xcode 12.2+ (ARM64)
- Windows: Ninja, Visual Studio 2015+
Ninja is a cross-platform open-source tool for running fast builds using pre-installed platform toolchains (GNU, clang, Xcode or MSVC). See comments in the «third_party/cef/cef_binary_*/CMakeLists.txt» file for Ninja usage instructions.
CEF provides a number of examples that you can use as a starting point or reference for your own CEF-based development.
- By default all example targets will be included in the project files generated using CMake.
- The CEF binary distribution includes cefsimple and cefclient sample applications.
- The cefsimple application demonstrates the minimal implementation required for a standalone executable target and is described on the Tutorial Wiki page.
- The cefclient application demonstrates a wide range of CEF functionality most of which is documented on the GeneralUsage Wiki page.
- The examples directory contains example targets that demonstrate specific aspects of CEF functionality.
- See the examples README.md file for information about the examples targets.
- Add -DWITH_EXAMPLES=Off to the cmake command-line if you do not wish to build the examples targets.
Here are some activities you might want to try next to gain a better understanding of CEF:
1. Update the CEF version used to build your local copy of cef-project:
- Visit the Spotify automated builder page to see what CEF versions are available.
- Change the «CEF_VERSION» value near the top of the top-level CMakeLists.txt file.
- Re-run the cmake and build commands. Add -DWITH_EXAMPLES=Off to the cmake command-line to disable targets from the examples directory because they may not build successfully with the new CEF version.
2. Add your own project source code:
- Create a new «myproject» directory in the root cef-project directory (e.g. «/path/to/cef-project/myproject»).
- Copy the contents of the «third_party/cef/cef_binary_*/tests/cefsimple» directory to «myproject» as a starting point.
- Add a new add_subdirectory(myproject) command near the end of top-level CMakeLists.txt file after the existing add_subdirectory commands.
- Change the «CEF_TARGET» and «CEF_HELPER_TARGET» values in «myproject/CMakeLists.txt» from «cefsimple» to «myproject».
- (Windows only) Rename the «cefclient.exe.manifest» file to «myproject.exe.manifest» in both «myproject/CMakeLists.txt» and the «myproject» directory.
- Re-run the cmake and build commands.
3. Gain a better understanding of the cefsimple application by reading the Tutorial Wiki page.
4. Fork the cef-project repository using Bitbucket and Git to store the source code for your own CEF-based project. See the ContributingWithGit Wiki page for details (replace all instances of «cef» with «cef-project» in those instructions).
5. Review the GeneralUsage Wiki page for additional details on CEF implementation and usage.
Support and Contributions
If you have any questions about CEF or cef-project please ask on the CEF Forum. If you would like to make contributions please see the «Helping Out» section of the CEF Main Page.
cef / Tutorial
This Wiki page explains how to create a simple application using CEF3.
Note to Editors: Changes made to this Wiki page without prior approval via the CEF Forum or Issue Tracker may be lost or reverted.
Introduction
This tutorial explains how to create a simple application using CEF3. It references the cefsimple example project. For complete CEF3 usage information visit the GeneralUsage Wiki page.
Getting Started
CEF provides a sample project that makes it really easy to get started with CEF development. Simply browse over to the cef-project website and follow the step-by-step instructions. The source files linked from this tutorial are for the current CEF3 master branch and may differ slightly from the versions that are downloaded by cef-project.
Loading a Custom URL
The cefsimple application loads google.com by default but you can change it to load a custom URL instead. The easiest way to load a different URL is via the command-line.
You can also edit the source code in cefsimple/simple_app.cc and recompile the application to load your custom URL by default.
Application Components
All CEF applications have the following primary components:
- The CEF dynamic library (libcef.dll on Windows, libcef.so on Linux, “Chromium Embedded Framework.framework” on OS X).
- Support files (*.pak and *.bin binary blobs, etc).
- Resources (html/js/css for built-in features, strings, etc).
- Client executable (cefsimple in this example).
The CEF dynamic library, support files and resources will be the same for every CEF-based application. They are included in the Debug/Release or Resources directory of the binary distribution. See the README.txt file included in the binary distribution for details on which of these files are required and which can be safely left out. See below for a detailed description of the required application layout on each platform.
Architecture in 60 Seconds
The below list summarizes the items of primary importance for this tutorial:
- CEF uses multiple processes. The main application process is called the “browser” process. Sub-processes will be created for renderers, plugins, GPU, etc.
- On Windows and Linux the same executable can be used for the main process and sub-processes. On OS X you are required to create a separate executable and app bundle for sub-processes.
- Most processes in CEF have multiple threads. CEF provides functions and interfaces for posting tasks between these various threads.
- Some callbacks and functions may only be used in particular processes or on particular threads. Make sure you read the source code comments in the API headers before you begin using a new callback or function for the first time.
Read the GeneralUsage Wiki page for complete discussion of the above points.
Source Code
The cefsimple application initializes CEF and creates a single popup browser window. The application terminates when all browser windows have been closed. Program flow is as follows:
- The OS executes the browser process entry point function (main or wWinMain).
- The entry point function:
- Creates an instance of SimpleApp which handles process-level callbacks.
- Initializes CEF and runs the CEF message loop.
- After initialization CEF calls SimpleApp::OnContextInitialized(). This method:
- Creates the singleton instance of SimpleHandler.
- Creates a browser window using CefBrowserHost::CreateBrowser().
- All browsers share the SimpleHandler instance which is responsible for customizing browser behavior and handling browser-related callbacks (life span, loading state, title display, etc).
- When a browser window is closed SimpleHandler::OnBeforeClose() is called. When all browser windows have closed the OnBeforeClose implementation quits the CEF message loop to exit the application.
Your binary distribution may include newer versions of the below files. However, the general concepts remain unchanged.
Entry Point Function
Execution begins in the browser process entry point function. This function is responsible for initializing CEF and any OS-related objects. For example, it installs X11 error handlers on Linux and allocates the necessary Cocoa objects on OS X. OS X has a separate entry point function for helper processes.
SimpleApp
SimpleApp is responsible for handling process-level callbacks. It exposes some interfaces/methods that are shared by multiple processes and some that are only called in a particular process. The CefBrowserProcessHandler interface, for example, is only called in the browser process. There’s a separate CefRenderProcessHandler interface (not shown in this example) that is only called in the render process. Note that GetBrowserProcessHandler() must return |this| because SimpleApp implements both CefApp and CefBrowserProcessHandler. See the GeneralUsage Wiki page or API header files for additional information on CefApp and related interfaces.
SimpleHandler
SimpleHandler is responsible for handling browser-level callbacks. These callbacks are executed in the browser process. In this example we use the same CefClient instance for all browsers, but your application can use different CefClient instances as appropriate. See the GeneralUsage Wiki page or API header files for additional information on CefClient and related interfaces.
Build Steps
Build steps vary depending on the platform. Explore the CMake files included with the binary distribution for a complete understanding of all required steps. The build steps common to all platforms can generally be summarized as follows:
- Compile the libcef_dll_wrapper static library.
- Compile the application source code files. Link against the libcef dynamic library and the libcef_dll_wrapper static library.
- Copy libraries and resources to the output directory.
Windows Build Steps
- Compile the libcef_dll_wrapper static library.
- Compile/link cefsimple.exe.
- Required source code files include: cefsimple_win.cc, simple_app.cc, simple_handler.cc, simple_handler_win.cc.
- Required link libraries include: comctl32.lib, shlwapi.lib, rcprt4.lib, libcef_dll_wrapper.lib, libcef.lib, cef_sandbox.lib. Note that cef_sandbox.lib (required for sandbox support) is a static library currently built with Visual Studio 2015 Update 3 and it may not compile with other Visual Studio versions. See comments in cefsimple_win.cc for how to disable sandbox support.
- Resource file is cefsimple.rc.
- Manifest files are cefsimple.exe.manifest and compatibility.manifest.
- Copy all files from the Resources directory to the output directory.
- Copy all files from the Debug/Release directory to the output directory.
The resulting directory structure looks like this for 2526 branch:
Linux Build Steps
- Compile the libcef_dll_wrapper static library.
- Compile/link cefsimple.
- Required source code files include: cefsimple_linux.cc, simple_app.cc, simple_handler.cc, simple_handler_linux.cc.
- Required link libraries include: libcef_dll_wrapper.a, libcef.so and dependencies (identified at build time using the “pkg-config” tool).
- Configure the rpath to find libcef.so in the current directory (“-Wl,-rpath,.”) or use the LD_LIBRARY_PATH environment variable.
- Copy all files from the Resources directory to the output directory.
- Copy all files from the Debug/Release directory to the output directory.
- Set SUID permissions on the chrome-sandbox executable to support the sandbox. See binary distribution build output for the necessary command.
The resulting directory structure looks like this for 2526 branch:
Mac OS X Build Steps
- Compile the libcef_dll_wrapper static library.
- Compile/link/package the “cefsimple Helper” app.
- Required source code files include: process_helper_mac.cc.
- Required link frameworks include: AppKit.framework.
- App bundle configuration is provided via “cefsimple/mac/helper-Info.plist”.
- Load the CEF Framework as described here.
- Compile/link/package the “cefsimple” app.
- Required source code files include: cefsimple_mac.mm, simple_app.cc, simple_handler.cc, simple_handler_mac.mm.
- Required link frameworks include: AppKit.framework.
- App bundle configuration is provided via “cefsimple/mac/Info.plist”.
- Load the CEF Framework as described here.
- Create a Contents/Frameworks directory in the cefsimple.app bundle. Copy the following files to that directory: “cefsimple Helper.app”, “Chromium Embedded Framework.framework”.
The resulting directory structure looks like this for 2526 branch:
Cef chromium mingw windows
The Chromium Embedded Framework (CEF) is a simple framework for embedding Chromium-based browsers in other applications.
- Project Page — https://bitbucket.org/chromiumembedded/cef
- Tutorial — https://bitbucket.org/chromiumembedded/cef/wiki/Tutorial
- General Usage — https://bitbucket.org/chromiumembedded/cef/wiki/GeneralUsage
- Master Build Quick-Start — https://bitbucket.org/chromiumembedded/cef/wiki/MasterBuildQuickStart
- Branches and Building — https://bitbucket.org/chromiumembedded/cef/wiki/BranchesAndBuilding
- Announcements — https://groups.google.com/forum/#!forum/cef-announce
- Support Forum — http://www.magpcss.org/ceforum/
- CEF1 C++ API Docs — http://magpcss.org/ceforum/apidocs/
- CEF3 C++ API Docs — http://magpcss.org/ceforum/apidocs3/
- Downloads — https://cef-builds.spotifycdn.com/index.html
- Donations — http://www.magpcss.org/ceforum/donate.php
CEF is a BSD-licensed open source project founded by Marshall Greenblatt in 2008 and based on the Google Chromium project. Unlike the Chromium project itself, which focuses mainly on Google Chrome application development, CEF focuses on facilitating embedded browser use cases in third-party applications. CEF insulates the user from the underlying Chromium and Blink code complexity by offering production-quality stable APIs, release branches tracking specific Chromium releases, and binary distributions. Most features in CEF have default implementations that provide rich functionality while requiring little or no integration work from the user. There are currently over 100 million installed instances of CEF around the world embedded in products from a wide range of companies and industries. A partial list of companies and products using CEF is available on the CEF Wikipedia page. Some use cases for CEF include:
- Embedding an HTML5-compliant Web browser control in an existing native application.
- Creating a light-weight native “shell” application that hosts a user interface developed primarily using Web technologies.
- Rendering Web content “off-screen” in applications that have their own custom drawing frameworks.
- Acting as a host for automated testing of existing Web properties and applications.
CEF supports a wide range of programming languages and operating systems and can be easily integrated into both new and existing applications. It was designed from the ground up with both performance and ease of use in mind. The base framework includes C and C++ programming interfaces exposed via native libraries that insulate the host application from Chromium and Blink implementation details. It provides close integration between the browser and the host application including support for custom plugins, protocols, JavaScript objects and JavaScript extensions. The host application can optionally control resource loading, navigation, context menus, printing and more, while taking advantage of the same performance and HTML5 technologies available in the Google Chrome Web browser.
Numerous individuals and organizations contribute time and resources to support CEF development, but more involvement from the community is always welcome. This includes support for both the core CEF project and external projects that integrate CEF with additional programming languages and frameworks (see the «External Projects» section below). If you are interested in donating time to help with CEF development please see the «Helping Out» section below. If you are interested in donating money to support general CEF development and infrastructure efforts please visit the CEF Donations page.
Users new to CEF development should start by reading the Tutorial Wiki page for an overview of CEF usage and then proceed to the GeneralUsage Wiki page for a more in-depth discussion or architectural and usage issues. Complete API documentation is available here. CEF support and related discussion is available on the CEF Forum.
Binary distributions, which include all files necessary to build a CEF-based application, are available on the Downloads page. Binary distributions are stand-alone and do not require the download of CEF or Chromium source code. Symbol files for debugging binary distributions of libcef can also be downloaded from the above links.
The CEF project is an extension of the Chromium project. CEF maintains development and release branches that track Chromium branches. CEF source code can be downloaded, built and packaged manually or with automated tools. Visit the BranchesAndBuilding Wiki page for more information.
The base CEF framework includes support for the C and C++ programming languages. Thanks to the hard work of external maintainers CEF can integrate with a number of other programming languages and frameworks. These external projects are not maintained by CEF so please contact the respective project maintainer if you have any questions or issues.
If you’re the maintainer of a project not listed above and would like your project listed here please either post to the CEF Forum or contact Marshall directly.
CEF is still very much a work in progress. Some ways that you can help out:
— Vote for issues in the CEF issue tracker that are important to you. This helps with development prioritization.
— Report any bugs that you find or feature requests that are important to you. Make sure to first search for existing issues before creating new ones. Please use the CEF Forum and not the issue tracker for usage questions. Each CEF issue should:
- Include the CEF revision or binary distribution version.
- Include information about your OS and compiler version.
- If the issue is a bug please provide detailed reproduction information.
- If the issue is a feature please describe why the feature is beneficial.
— Write unit tests for new or existing functionality.
— Pull requests and patches are welcome. View open issues in the CEF issue tracker or search for TODO(cef) in the source code for ideas.
If you would like to contribute source code changes to CEF please follow the below guidelines:
— Create or find an appropriate issue for each distinct bug, feature or change.
— Submit a pull request or create a patch with your changes and attach it to the CEF issue. Changes should:
- Be submitted against the current CEF master branch unless explicitly fixing a bug in a CEF release branch.
- Follow the style of existing CEF source files. In general CEF uses the Chromium coding style.
- Include new or modified unit tests as appropriate to the functionality.
- Not include unnecessary or unrelated changes.
About
Chromium Embedded Framework (CEF) official mirror. A simple framework for embedding Chromium-based browsers in other applications.
