Downloads Documentation Compatibility Release Notes Features Licensing Support Samples mobileFX

WebKitX ActiveX for CEF3

This is a Visual Studio C++14 MFC/ATL ActiveX that wraps Chromium Embedded Framework (CEF3) for use with OLE/COM languages. Chromium Embedded Framework encapsulates WebKit Blink HTML5 Renderer and Google V8 JavaScript VM Engine. This is a production-grade stable component for commercial use that will truly add HTML5 features in your Desktop and Terminal Applications.

Table of Contents

Key Features

Downloads

Subscribe to New Version Notifications and Offers! Getting Started Documentation & Material
Product Details Released Architectures CEF3 Download Installation Package
WebKitX_CEF3_ActiveX_x86_v2.0.0.7680.exe
  • For 32-bit Application Development
  • Windows 7, 8, 10 (32-bit or 64-bit)
  • Terminal Ready: Windows 7 POS Edition
  • Blink HTML5 Rendering Engine
  • WebGL v1, v2
  • 4 GB RAM Recommended
  • Peper Flash Player v31.0.0.122 (32-bit)
  • 75 MB Redistributable
  • Commercial Use License
  • Bounty Support
20 Apr 2019 x86 & x64
32-bit OCX

VC++ 2017
Redist
Chromium Version: 71
Git Branch: 3578.1860
Released: Dec 2018
Download
MD5: d4be16b7bf4ff19e5ab13309702b0a96
SHA-1: f24dcc8521ff7489ed5a242fd47ab6215f7c02f8
WebKitX_CEF3_ActiveX_x64_v2.0.0.7680.exe
  • For 64-bit Application Development
  • Windows 7, 8, 10 (64-bit)
  • Terminal Ready: Windows 7 POS Edition
  • Blink HTML5 Rendering Engine
  • WebGL v1, v2
  • 8 GB RAM Recommended
  • Peper Flash Player v31.0.0.122 (64-bit)
  • 81 MB Redistributable
  • Commercial Use License
  • Bounty Support
20 Apr 2019 x64
64-bit OCX

VC++ 2017
Redist
Chromium Version: 71
Git Branch: 3578.1860
Released: Dec 2018
Download
MD5: 45c760140a5494daf41b7065fddd3009
SHA-1: 8fd41f9a44811198ccd066188e01a2b076ca900a
WebKitX_CEF3_ActiveX_WinXP_x86_v2.0.0.7680.exe
  • For 32-bit Application Development
  • Windows XP x86 SP3 (32-bit)
  • Windows Vista x86 (32-bit)
  • Terminal Ready: Windows XP POS & Embedded Editions
  • Tested with unofficial SP4 (Major Geeks)
  • Tested with XP POS Windows Updates up to 12/2018
  • WebKit HTML5 Rendering Engine
  • With WebGL 1.0 Support
  • 2 GB RAM Recommended
  • Peper Flash Player v29.0.0.113 (32-bit)
  • 55 MB Redistributable
  • Commercial Use License
  • Bounty Support (Limited)
20 Apr 2019 x86
32-bit OCX

VC++ 2015
Redist
Chromium Version: 49
Git Branch: 2623.1401
Released: May 2016
Download
MD5: cf11fa1ea9ee82e68829c4ec9dd18230
SHA-1: 209ab791e89894225d300d45cc9c19aff9aba6eb
WebKitX_CEF3_ActiveX_x86_v1.5.11.7683.exe
  • Discontinued 
  • Long Time Support (LTS) ends December 2019
  • For 32-bit Application Development
  • Windows 7, 8, 10 (32-bit or 64-bit)
  • Terminal Ready: Windows 7 POS Edition
  • WebKit HTML5 Rendering Engine
  • WebGL v1
  • 4 GB RAM Recommended
  • Peper Flash Player v29.0.0.113 (32-bit)
  • 73 MB Redistributable
  • Bounty Support (Existing Contracts Only)
20 Apr 2019 x86 & x64
32-bit OCX

VC++ 2015
Redist
Chromium Version: 64
Git Branch: 3282.1724
Released: Dec 2017
Download
MD5: 6e5ffa7bffbb14a804859ce38612156e
SHA-1: a52157249b127a6f18da4c78b49482c75b071079

Compatibility

Even though the control is promoted and supported only for Visual Basic 6.0 SP6, it is compatible with any OLE/COM capable Integrated Development Environments and x86 programming language. The following programming languages and IDE are reported to be compatible with WebKitX:

Release Notes

20 Apr 2019

Mar 2019

Feb 2019

Jan 2019

Features

In-Process ActiveX with Out-Of-Process Chromium

WebKitX CEF3 ActiveX is a light-weight MFC ATL component for use with OLE/COM Programming Languages. At runtime the ActiveX starts CEF3XClient.exe process, passing to it its Window Handle (hWnd). 

CEF3XClient Process starts CEF3 Browser and Render sub-processes and establishes a seamless back-to-back Interprocess Communication Mechanism (IPC) between the ActiveX and all CEF3 processes. Chrome Browser is parented in ActiveX hWnd but lives in its own process.

All COM-based method and property calls between the ActiveX and CEF3XClients are marshalled using CoWaitForMultipleHandles, allowing your application's UI to be responsive. For time-consuming tasks, such as URL loading, COM events provide you callbacks when the tasks are finished. 

The important aspect of this architecture design is that all WebKit HTML5 rendering and V8 JavaScript execution are taking place outside your application, offering your application stability and isolation.

Plugins

WebKitX supports PDF Viewer, PDF Printer, Flash Player and Chrome Developer Tools plugins out of the box.

PDF Viewer Plugin

Flash Player Plugin

Chrome DevTools Plugin

Accessing HTML5 DOM with CSS3 Selector API

WebKitX provides methods to access HTML5 DOM through CSS3 selectors (Selector example td:nth-of-type(3) > span:first-child). Selectors are used as arguments in editing and styling method calls and as targets in events. The ActiveX provides the selector of the currently selected element and the begin and end nodes of the current selection: ActiveElement, SelAnchorElement, SelFocusElement.

URL Loading Events

WebKitX provides several Events during its initialization, creation of the browser and loading of a URL. First you need to set the licensing information by handling the early Form Loading or Creation event. Then you can control CEF Browser creation by handling the OnCreate event. Once the browser is ready it will emit the the OnBrowserReady event where you can enable JavaScript or HTML5 editing parameters. In OnBrowserReady you should also load the HTML5 markup or navigate to the URL you want to load. During loading WebKitX will fire several loading events such as OnLoadStart and OnLoadEnd. If you are loading HTML with frames (IFRAMEs) then some events will fire multiple times, such as OnPageLoadStart and OnPageLoadEnd. When the main frame is loaded WebKitX will fire OnLoadEnd and when all frames have loaded WebKitX will fire the OnPageComplete event.

When you receive the OnLoadEnd and OnPageLoadEnd events, it means that network-wise the contents have downloaded but HTML-wise the contents might not be fully parsed yet. In HTML terms this means that document.readyState value might not not set to complete. Pages in window or sub frames might be in interactive state and resources might be loading in the background. The only event that guarantees that the main window frame and all sub-frames have document.readyState = complete is OnPageComplete. Internally, WebKitX uses an asynchronous task that checks the document.readyState for all frames; if this check result is "complete" with a count equal to browser frames, then the event is fired. If some frames have loaded while other frames have failed, the event will not fire. The check takes place on a fresh HTML DOM snapshot obtained every time at the moment of the check, and examines the current number of frames. The frames must remain unchanged for 3 seconds before the event is fired; this way, any dynamic loading or unloading of frames is taken into account.

Please note that some frameworks such as Angular and React dynamically load portions of the page. WebKitX events will keep firing while dynamic content is downloaded. You need to examine the behavior of the control in relation with the web site you want to display and adjust your event handling accordingly.

Calling JavaScript Functions from your App

Calling JavaScript Functions with CallByName()

The simplest way to call a JavaScript function in WebKitX is WebKitX.CallByName(Name, Variant) method. You can pass to JavaScript function arbitrary arguments using an OLE/COM Variant, and receive the function's result value, as an OLE/COM Variant too. Execution of CallByName is IPC-synchronous and this method is an elegant alternative to WebKitX.Eval() code as you can pass back-and-forth your variables without stringifying them. For more information about this mechanism have a look in OLE/COM Variants to V8 Values Conversion.

Calling JavaScript Functions with JSCallback()

WebKitX JavaScript Callbacks is a mechanism to register and call JavaScript functions by name, within a specific V8 JavaScript Execution Context. The key difference from CallByName() is that CallByName can only invoke functions registered in the Global Scope of the Main Window, where as JavaScript Callbacks allow you to call functions registered in any scope and window.

Calling Native Functions from JavaScript

Calling Native Functions with window.postComMessage()

To call native function from JavaScript you can use window.postComMessage that fires the OnPostComMessage event in your application. You can pass an arbitrary length of Scalar JavaScript values as arguments to postComMessage.

Native Tier:

JavaScript Tier:

DOM to COM Events

Asynchronous Events

HTML5 DOM Events are generated by WebKit Blink Engine and are copied into an immutable format before they are transmitted from CEFXClient process to WebKitX ActiveX. Once WebKitX ActiveX receives an event notification through IPC, it fires a COM Event with the copied data of HTML DOM event. Thus, CEFXClient process does not block waiting for your client code to handle the event. WebKitX DOM Events are Immutable, meaning that you can only read event data but you cannot cancel events, stop them from bubbling or prevent default behavior. 

Synchronous Events

WebKitX supports synchronous DOM to COM events by implementing CefMessageRouter circuit. Events generated from WebKit Blink Engine are serialized and passed from Rendering to Browser process, which transmits them to the ActiveX. The browser process waits for the ActiveX to handle the event, where you can also cancel event bubble or prevent event's default behavior.

Firing Custom HTML5 Events - DispatchEvent()

WebKitX DispatchEvent() method allows you to fire DOM events directly into JavaScript and handle those events by JavaScript event handlers. You can pass the target selector that will receive the event, the event name, event initialization parameters (bubbling, cancelable, composed) and an OLE/COM Variant that will be converted into a V8 JavaScript object and added in the details field of the Event object. Event execution can be both synchronous and asynchronous in terms of IPC tunneling, and it is always synchronous in terms of DOM.

Content Filtering EXPERIMENTAL

WebKitX Content Filtering is a mechanism that allows you to remove HTTP Response Headers, such as Content Security Policy (CSP) response header, and alter or remove  Cross Origin Resource Sharing (CORS) response header. WebKitX implements in CEF3 Client I/O Thread a custom Resource Handler that intercepts normal HTTP and HTTPS requests and spawns a light-weight object that downloads the resource instead. Once the HTTP Response Headers for a particular resource are available, they are being filtered-out and passed to the IO thread for further processing. 

This mechanism works for the following HTTP methods: GET, POST, HEAD, DELETE and PUT, and works for any MIME type resource. WebKitX content filtering works both with HTTP and HTTPS requests, meaning that it works perfectly with server-side SSL encryption, but it does not work if client-side SSL authentication is enabled. Please read further below for more information about Microsoft IIS Client SSL certificate configuration.

Licensing

License Agreement

Please read carefully our license agreement and do not hesitate to contact us if you have questions, or if you need to negotiate special closures. 
mobileFX Software End-User License Agreement for WebKitX ActiveX Control

Desktop Application License

In a nutshell, a single License allows you to develop an unlimited number of Desktop Applications linked with WebKitX ActiveX control and distribute them freely to an unlimited number of your customers. The license excludes specific terminal-based applications that are subject to Terminal Application License below.

Product Bundle Compatibility Commercial Use Price Buy Now
WebKitX ActiveX x86 v2.x (32-bit ActiveX) Windows 7, 8, 10 Yes £ 599
WebKitX ActiveX x64 v2.x (64-bit ActiveX) Windows 7, 8, 10 Yes £ 999
WebKitX ActiveX x86 v2.x (32-bit ActiveX for Windows XP) Windows XP, Vista Yes £ 999

Upgrade Discount from Version 1.x

Version 1.x Customers are entitled to 20% upgrade discount to Version 2.x at any time within 2019. Please contact info@mobilefx.com to request your upgrade. In version 1.x WebKitX ActiveX was shipped in two editions, the Browser and the Editor. In version 2.x the control offers both functions in a single executable with no API restrictions.

Do I need additional Licenses?

If your application is installed and executed on Windows Desktop operating systems such as Windows XP, Vista, 7, 8, 10 and Windows Server editions, then you only need the Desktop Application License; to be absolutely clear about this, if your application is installed and executed on Windows Desktop operating systems such as Windows 7, 8, 10 and Windows Server editions, then you do not need Terminal Licenses. You will need Terminal Licenses only if your application will be installed and executed on Windows Embedded operating systems, or executed under a Terminal Server, or under a Virtual Machine.

Terminal Application Licensing

Complementary to Desktop Application License are Terminal Licenses

A Terminal License is required if your application is deployed on a  Windows Embedded operating system or under a Terminal Server. A Terminal License must be obtained per terminal, on top of the commercial license. There are (3) types of terminal applications distinguished in the licensing terms:

The Point of Sales Terminal License is the General Purpose Terminal License for all terminal applications not explicitly stated in the list above.

Please contact us for Terminal License Volume Quotation.


Terminal License Commercial Use Terms Indicative Annual OPEX Price Volume License Quotation
Video Lottery Terminal License Yes CAPEX or OPEX £ 5
Contact us
Digital Signage Player License Yes CAPEX or OPEX £ 3
Contact us
Point of Sales Terminal License Yes CAPEX or OPEX £ 1
Contact us

Ordering via Purchase Order (PO)

Alternative to automated PayPal order processing and only for company, school or university purchases, we offer a manual order processing and payment method via Purchase Order and IBAN wire transfer. Please create a Purchase Order (PO) document indicating the Software Name, Software EditionLicenses Quantity and/or Support Vouchers Quantity you wish to purchase. You must also provide company, school or university name, address, telephone and contact details. If your company, school or university is registered in a European Union member country you must provide in your PO your VAT number, if applicable. Please forward your PO to info@mobilefx.com and upon processing you will receive payment instructions for IBAN Wire Transfer.

Click here to download our standard Purchase Order document

The typical process is:

  1. Send us a PO with the Software Edition, qty, your company, school or university details.
  2. We reply with quotation PDF and a Quotation Number.
  3. Your company makes the payment through IBAN wire transfer with the Quotation Number in description field.
  4. The Activation Keys are generated to Company Name. If you need them bound to an email, please specify this in PO.
  5. We send you the Activation Keys printed on the VAT invoice PDF.

Let us know if something different is required in the steps above.

Please do not hesitate to contact us for clarifications and assistance.

Support Services

What is Support Voucher / Bounty?

If you desperately need a new feature implemented in WebKitX or immediately need a hotfix and can't wait until next release, you can contact us at info@mobilefx.com and negotiate with us a price, for which we will stop what we do and take care of what you need! The service is called a Bounty and applies only to existing Customers; for any edition of the ActiveX but only for its latest version (we do not branch per customer).

Just send us an email with what you need and our Account Manager will pass your request to our Tech Lead for Effort Estimation along with Technical Specs of the works to be done. Effort Estimation is in man hours and it is different from Duration. For example, to add a feature it might take our experts 8 hours to implement, but because we work on Sprints we might need a duration of one week to deliver.

The catch is that you participate in the process, being the primary Beta Tester! This phase is called User Acceptance Testing (UAT) and during this period you receive code-locked prototype revisions and provide us with valuable feedback, such as UAT observations and Defects. Once UAT is completed and you are satisfied with the result, you release us from the Bounty and we provide you with an Unlock Code as a token of our appreciation.

For corporate customers and long projects we collaborate using Jira.

Service Duration or Effort Price
Support Voucher / Bounty 2 hours (minimum) £ 100

Premium Support Services

Commercial Distribution

Creating a setup script to install WebKitX on a different computer should be straight-forward:

  1. For x86 your script must copy the files of the C:\Program Files (x86)\WebKitX CEF3 ActiveX\bin folder to the other computer.
    The destination folder is irrelevant and can be anywhere you choose.
  2. For x64 your script must copy the files of the C:\Program Files\WebKitX CEF3 ActiveX\bin folder to the other computer.
    The destination folder is irrelevant and can be anywhere you choose.
  3. For x86 your script must run Microsoft Visual C++ 2015 Redistributable Package (x86) for the Windows OS and Service Pack bundle of the other computer.
    For detailed information please see the WebKitX Runtime Dependencies paragraph above.
  4. For x64 your script must run Microsoft Visual C++ 2015 Redistributable Package (x64) for the Windows OS and Service Pack bundle of the other computer.
    For detailed information please see the WebKitX Runtime Dependencies paragraph above.
  5. Your script must register WebKitX ActiveX into the Windows Registry using this command: regsvr32 /s WebKitXCEF3.ocx
  6. If your product does not use Chrome DevTools, you may skip devtools_resources.pak to decrease size.
  7. If your product uses Flash Player you should add Pepper Flash Player.

WebKitX Runtime Dependencies

WebKitX requires Microsoft C++ Runtime. During installation WebKitX setup will automatically install Microsoft C++ Redistributable Package for the following list of Windows Operating Systems:


The latest supported Visual C++ downloads by Microsoft
https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads

.NET Redistributables (for C# samples)
http://download.microsoft.com/download/F/9/4/F942F07D-F26F-4F30-B4E3-EBD54FABA377/NDP462-KB3151800-x86-x64-AllOS-ENU.exe

Visual Basic 6.0 Redistributables (for VB Samples)
http://support.microsoft.com/default.aspx?scid=kb;en-us;290887

Samples

HTML5 Editor (VB6)

This is a simple, yet complete, sample of WebKitX CEF3 ActiveX control. The sample is shipped both as Visual Basic 6 source code project, as well as a complete binary bundle that includes CodeMax Editor ActiveX and CEF3 binaries. The sample demonstrates all WebKitX advanced features including FrontPage-like selection synchronization between HTML5 Designer and Source Editor, Table Editing, Selector API, and advanced CSS3 styling. The binary bundle can be used as a royalties-free stand-alone HTML5 Editor.





Simple Browser (VB6)

This sample demonstrates the WebKitX Browser. You can embed WebKitX in your applications with just 3 lines of code!

Simple Browser (C#)

The sample demonstrates using WebKitX from C# for both 32-bit and 64-bit application development.

Other mobileFX Products

CairoCanvasX is an HTML5 Canvas 2D Rendering Context for use with OLE/COM languages that does not require HTML5 run-time. The ActiveX is linked with Cairo 2D Graphics Library version 1.10.2 from GTK+ 2.24 win32 implementation. This is a production-grade stable component for commercial use that will add hardware accelerated vector graphics in your desktop applications and 2D games. Effort has been made to preserve HTML5 canvas API in order to offer smooth web to desktop porting and vice versa.

Find out more about CairoCanvasX

Coconut2D is an Integrated Development Environment (IDE) for WebGL Games and Classic ASP Web Applications powered by node.js. It looks and works a lot like Flash for games, with a Scene Designer and a 2D Animation Model, and like Dreamweaver for web apps with an HTML5 / ASP Editor powered by WebKitX Engine. Coconut2D integrates both with Google Chrome and node.js allowing you to write and debug the client and the server code of your games. Coconut2D Market Place offers Plugins, Tools, Compilers, Frameworks and Assets that will boost your productivity and minimize your dependency on 3rd party tools.

Find out more about Cocont2D