WebKitX ActiveX for CEF3

This is a Visual Studio 2015 C++11 MFC/ATL x86 ActiveX that wraps Chromium Embedded Framework (CEF3) version 3.3202.1692 (December 2017) 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

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:

• Visual Basic 6.0 SP6 SUPPORTED
• Microsoft Visual Studio .NET 2010/2015/2017 (VB.Net, C#, only for 32-bit)
• Microsoft Office Visual Basic for Applications 2003/2007/2010/2015/2016 (VBA, Access, Excel, etc., only 32-bit)
• Borland Delphi (down to version 5.0)
• Embarcadero Delphi (any Windows version, only for 32-bit)
• Qt (any Windows version, only for 32-bit)
• Xojo 2017 (any Windows version, only for 32-bit)
• Visual FoxPro
• PowerBuilder
• WinBatch
• Internet Explorer (requires NirSoft ActiveX Compatibility Manager)
• Ruby (via the 'win32ole' library included in the standard Ruby 1.8.x or later distribution)
• dBase (from 12 Plus down to 2.80 Plus)

Release Notes

12 Nov 2018

• New Feature Allowing Flash Plugin pepflashplayer32_29_0_0_113.dll (version 29.0.0.113) to start without need for right-click and "Run Plugin" command.

12 Oct 2018

• Hot Fix Prevent CEF3 window resizing when WebKitX control is invisible. This fixes rendering problems when using the control with TabStrips.
• New Feature Added SetAutoResize(Enable) method to further control CEF3 Auto Resizing. Auto Resize is enabled by default (legacy).

24 Sep 2018

• Hot Fix Further to Common Controls issues with VB6, Common Controls Manifest removed from OCX but preserved manifest in CEF3 processes.

18 Sep 2018

• New Feature Added support for Tooltips (<p title="I am a tooltip">).
• Hot Fix Embedded Common Controls Manifest in ActiveX OCX and CEF Client Process.

12 Sep 2018

• New Feature Improved support for Angular.js dynamic loading sites with multiple secondary rendering processes.
• Hot Fix Fixed rendering process bug related to dynamic and Angular.js sites causing rendering processes to crash (eg. https://bild.de).
• Hot Fix Patched CEF3 encoding bug in experimental Content Filtering feature that causes invalid characters in pages such as Google.gr, Amazon.de, etc.
• Hot Fix Fixed bug related with utility processes that was causing a crash message to display when printing (even though the control was not crashing).
• Hot Fix Fixed bug in SetPreference() when passing stirng values.
• Hot Fix Improvements in Table Cell Editing and formatting commands.
• New Feature Added Settings.show_context_menu in OnCreate() to control context menu display.
• Binary Compatibility Break Renamed Print() method to PrintDocument().

12 Jul 2018

• Hot Fix Fixed an Editor bug that was causing &, <, > and other HTML entities inside a <script> to get HTML encoded (&amp; &lt; &gt;) due to XMLSerializer.
• New Feature Added Settings.enable_xml_html in OnCreate() to treat HTML as XML by explicitly using XMLSerializer to get HTML source.
• New Feature Added Settings.filter_response in OnCreate() to enable content filtering of the main browser and sub-browser (IFRAME) windows.
• New Feature Added Settings.access_control_allow_origin in OnCreate() to overwrite Cross-Origin Resource Sharing (CORS) response headers.
• New Feature Added Settings.remove_response_headers in OnCreate() to suppress Content Security Policy (CSP) response headers.
• New Sample HTML5 Editor sample demonstrates content filtering features.

12 Jun 2018

• New Feature Added WebKitX.SetMDIWindow() to treat overlapping MDI child window rendering problems.
• New Feature Added window.__WEBKITX_EDITABLE__ to detect edit mode.
• New Feature Allowed SaveHTML(FileName) to Browser License.
• New Feature Added SavePDF(FileName, LandScape) method.
• Hot Fix ShowDevTools() improvement; it does not require enabling JavaScript.
• New License Agreement New License Agreement for Desktop & Terminal Applications, for purchases after 18/05/2018. No business change for existing customers.
• License Key Break New Licensing breaks License Key compatibility. Existing customers please contact info@mobilefx.com for free license key upgrade.
• New Feature Implemented synchronous Events with Prevent Default and Cancel Bubble functionality. Synchronous events are serialized and not concurrent.
• Binary Compatibility Break Added Async attribute in AddEventListener to support synchronous Events. For backwards compatibility append True to existing code.
• Binary Compatibility Break OnEvent, AddressOf and IDispatch event handlers have Async, PreventDefault and CancelBubble arguments added to their signatures.
• New Feature Added FireOnEventForAllEvents property. When false, OnEvent() fires if AddressOf or IDispatch events handler are not set for enumerable events.
• New Feature Added WebKitX.DispatchEvent(Selector, Name, Bubbles, Cancelable, Composed, Detail, Async) method that fires a Custom Event.
• Hot Fix Overall thread safety and performance improvements for multi-threaded applications.
• Hot Fix Please Run Tests Added synchronization mutexes to serialize overlapping Eval(), JSCallback(), CallByName() and ExecCommand() calls.
• Hot Fix Fixed severe memory leak in CEF3XClient.exe. IPC message bytes transmitted from Browser to Render process were not released.

12 May 2018

• New Feature Added JavaScript Callbacks: window.register(fnName, fnCallback, this) and WebKitX.JSCallback(fnName, variant, async) invocation circuit.
• New Sample Minor improvement to Simple Browser sample code to support web sites with JavaScript code.
• Hot Fix Improved postComMessage to support variable length arguments that are passed as Variant String Array.
• Hot Fix Fixed memory leaks on Variants and BSTR.
• Binary Compatibility Break Changed OnBeforeNavigate event signature, added request, browser and frame identification and URL parameters.

12 Apr 2018

• Hot Fix Fixed undo commit synchronization issue causing random editing command timeouts.
• Hot Fix Escaping improvements to methods with String arguments (passing strings with quotes and CR/LF issues).
• New Feature Added support for Flash player. Flash plugin DLL must be downloaded and installed separately.
• New Feature Added file download support with OnBeforeDownload and OnDownloadUpdated events.
• New Feature Added explicit Download() method to initiate download from code.
• New Feature Added CancelDownload() method to cancel download from code.
• Hot Fix Implemented NavigateBack() functionality.
• Hot Fix Implemented NavigateForward() functionality.
• Hot Fix Implemented StopLoading() functionality.
• New Feature Added OnBeforeNavigate(URL, Cancel) event allowing replacing URL or cancelling.
• New Sample Added Tests Menu in HTML5 Editor Sample to demonstrate certain Workflows line cancelling navigation, viewing PDF files, etc.

18 Mar 2018

• Hot Fix Improved Eval functionality.

19 Feb 2018

• Hot Fix Improved IPC synchronization during control initialization.
• Hot Fix Fixed DownloadScripts intermittent bug that was occasionally causing scripts not to download.
• New Feature Added IPC_TIMEOUT_MILLIS property that defaults to 30 sec.
• New Feature Added OnIPCTimeOut() event for detecting IPC timeouts.

12 Feb 2018

• Hot Fix Fixed double-firing of OnLoadEnd event during control initialization.
• Hot Fix Fixed IDispatch addEventListenerEx method bug.
• New Sample Added Events sample demonstrating Event Handling with all possible methods.
• Hot Fix Improved implementation of Remove Formatting.
• Hot Fix Improved SetPreferences to avoid re-initializing CEF3 browser if possible (faster).
• New Feature Added ShowDevTools() method.
• New Feature Added AddScript(URL) method for dynamically adding JavaScript sources by URL.
• New Feature Added AddCode(JavaScript) method for dynamically adding JavaScript sources by code.
• New Feature Added custom Undo / Redo API with several helper properties, methods and events.
• New Feature Added support for CSS3 Gradients in styling methods.
• New Feature Added window.postComMessage(arguments..) that fires an WebKitX_OnComPostMessage(VARIANT) in VB6.
• New Feature Added OnCreate(ByVal Settings As WebKitXCEF3Lib.ISettings, CommandLineSwitches As String) initialization event.
• New Feature Added explicit Cache, User Preferences and Cookies persistence settings through OnCreate event and Settings object.
• Binary Compatibility Break Deprecated event OnGetPreferences due to misleading name. Please use OnCreate.

12 Jan 2018

• Hot Fix Fixed "Menu Not Showing Bug" - installer was placing localization files in wrong folder.

Evaluation & Distribution

Installation

Download the setup package and install it in a place like C:\Program Files (x86)\WebKitX CEF3 ActiveX and you are ready to start using the component.

Evaluation

You are welcome to evaluate WebKitX for as long as you want and feel free to contact us with your questions, your suggestions and your bounties!  During evaluation, when opening a URL and at random intervals WebKitX displays a message box informing you that it is a commercial product and that it requires a License, but it wont prevent you from using all its features.

Commercial License Activation

If you own a commercial license of WebKitX ActiveX control, you need to add in your program your License Key.
Add this line in your code: WebKitX1.Activate "your@email", "yourkey"

Commercial Distribution

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

1. Your script must copy the files of the C:\Program Files (x86)\WebKitX CEF3 ActiveX\bin folder to the other computer (list below).
   The destination folder is irrelevant and can be anywhere you choose.
2. 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.
3. Your script must register WebKitX ActiveX into the Windows Registry using this command: regsvr32 /s WebKitXCEF3.ocx
4. If your product does not use Chrome DevTools, you may skip devtools_resources.pak to decrease size.
5. If your product uses Flash Player you should add pepflashplayer32_29_0_0_113.dll (not included in WebKitX).

The binary payload of WebKitX consists of the following files and folders, all located in the ./bin folder:

• locales
• swiftshader
• WebKitXCEF3.ocx
• CEF3XClient.exe
• chrome_elf.dll
• d3dcompiler_43.dll
• d3dcompiler_47.dll
• libcef.dll
• libEGL.dll
• libGLESv2.dll
• tidy.dll
• widevinecdmadapter.dll
• natives_blob.bin
• snapshot_blob.bin
• v8_context_snapshot.bin
• icudtl.dat
• cef.pak
• cef_100_percent.pak
• cef_200_percent.pak
• cef_extensions.pak
• devtools_resources.pak

WebKitX Runtime Dependencies

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

• Windows 7 Service Pack 1 SUPPORTED
• Windows 8
• Windows 8.1
• Windows Server 2008 R2 Service Pack 1 
• Windows Server 2008 Service Pack 2
• Windows Server 2012
• Windows Vista Service Pack 2
• Windows XP Service Pack 3

Please note that OS-related compatibility issues are not subject to support and you must refer to Chromium Embedded Framework (CEF3) Operating System and Service Pack compatibility notes for aid.

What is Microsoft Visual C++ 2015 Redistributable Package?

Microsoft Visual C++ 2015 Redistributable installs run-time components of Visual C++ libraries. These components are required to run C++ applications that are developed using Visual Studio 2015 Update 3 RC and link dynamically to Visual C++ libraries. The packages can be used to run such applications on a computer even if it does not have Visual Studio 2015 installed. These packages also install run-time components of C Runtime (CRT), Standard C++, MFC, C++ AMP, and OpenMP libraries.Microsoft Visual C++ 2015 Redistributable includes bug fixes to the runtime DLLs and also the latest versions for KB 2999226. To find out what's new in Visual Studio 2015 Update 3 RC, see the Visual Studio 2015 Update 3 RC Release Notes.

WebKitX installation Fails. What can I do?

If during WebKitX installation you get an error message that WebKitXCEF3.ocx and cmax40.dll failed to register, it most certainly means that  Microsoft x86 C++ 2015 Redistributable Package failed to automatically install because the Windows OS version and/or its current Service Pack are not compatible with the included Microsoft x86 C++ 2015 Redistributable Package. You are advised to download Microsoft x86 C++ 2015 Redistributable Package for you Operating System and Service Pack bundle, and install it manually, from here: Microsoft Visual C++ 2015 Redistributable Update 3 RC.

Where can I find CEF3 binaries?

CEF3 binaries bundle can be also downloaded separately from here:
http://opensource.spotify.com/cefbuilds/index.html#windows32_builds
* WebKitX is tested and supported with cef_binary_3.3202.1692.g18a939d_windows32

WebKitX Editions

Which WebKitX edition do I need?

WebKitX ActiveX ships in two flavors: HTML5 Browser-only for adding HTML5 browsing capabilities in your applications, and HTML5 Browser & Editor for adding HTML5 What-You-See-Is-What-You-Get editing capabilities to your applications. For checking-out WebKitX editing features we recommend running the compiled sample HTML5 Editor.

WebKitX Browser Edition

Please note that HTML5 Browser Edition of WebKitX allows you to open URLs, read/write HTML5, receive  HTML5 events in your application, but it does not support HTML manipulation, nor JavaScript injection, nor JavaScript execution (Eval, AddScript, AddCode, JSCallback, DispatchEvent). The intended use of the Browser Edition of WebKitX is to render HTML5 from within your application such as Web Sites, WebGL Games, Help Files and Documentation, Sales and other Reports, RSS and News Feeds, HTML5 Videos, Facebook, Twitter tweets, PDF Files, Flash Content, etc.

WebKitX Editor & Browser Edition

If your application requires HTML5 manipulation, rich text editing, and/or JavaScript injection and execution, usage of Eval, AddScript, AddCode, JSCallback, DispatchEvent methods,  please consider using the HTML5 Browser & Editor edition of WebKitX. Despite being an HTML5 Editor, the control offers you its Editing API even in Browser Mode.

WebKitX Licensing

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.

Edition	Commercial Use	Price	23rd November 2018
WebKitX HTML5 Editor (x86)	Yes	£ 399

Edition	Commercial Use	Price	Buy Now
WebKitX HTML5 Browser (x86)	Yes	£ 399
WebKitX HTML5 Editor (x86)	Yes	£ 999

Choose your License based on API usage

Below is a list of all WebKitX API Methods and Properties and the License required in order to call them at run-time. Please check carefully if the methods you require for your application are covered by the licensing you choose. Please do not hesitate to contact us at info@mobilefx.com for assistance or clarifications.

Do I need additional Licenses?

If your application is installed and executed on Windows Desktop operating systems such as Windows 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.

Terminal Application License

Terminal Application License Premium Support Services

• Advanced Cache Control
• COM Object JavaScript Wrapper (invoke COM Objects from JavaScript)
• HTML5 Games Support (JavaScript Game to Lobby Communication Library)
• Flash Games Support (AS3 External Interface)
• Cross-Origin Resource Sharing Control (CORS)
• Barcode / QRCode Decoder

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

Can I upgrade my Browser License to Editor License?

Can I get the Source Code?

Yes you can! In fact we do not just give you the source code, we give you access to our git repository so that you can get all the latest fixes and features of our work in real-time.

Service	Commercial Use	Price
WebKitX Source Code	Yes	£ 25,000
Support Voucher / Bounty	1 hour	£ 50

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 Edition, Licenses 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.

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.

WebKitX Architecture

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.

Getting Started

Form_Load()

First you must activate WebKitX ActiveX by providing your License Key. If you are using early binding, a good place to do that is on Form_Load event. If you are using late binding you are advised to activate the control straight after its creation. This step applies only to license owners. During trial evaluation of WebKitX you may skip it.

WebKitX1_OnCreate(Settings, CommandLineSwitches)

Next you may control the creation of CEF3 Browser and Client Processes. OnCreate event provides you a Settings object that controls CEF3 Application and CEF3 Browser creation and initialization settings. The recommended defaults are preset in this object but you may want to provide your own settings such as Localization, Cache paths, Security settings, etc. The second parameter is CommandLineSwitches that are additional CEF3 preferences and even JavaScript flags that you want to provide to CEF3 Client Processes. 

For a list of command line switches please have a look here:  https://peter.sh/experiments/chromium-command-line-switches

Default WebKitX CEF3 Command Line Switches

• --disable-logging
• --allow-file-access
• --allow-file-access-from-files
• --allow-insecure-localhost
• --allow-running-insecure-content
• --disable-domain-blocking-for-3d-apis
• --allow-insecure-localhost
• --ignore-urlfetcher-cert-requests
• --cipher-suite-blacklist=0x0005,0x0004,0x002f,0xc012,0xc011,0x003c,0xc011,0x0032,0xc007,0xc00c   (Why?)
• --ssl-version-min=tls1 (Why?)
• --enable-encrypted-media
• --ignore-certificate-errors
• --disable-machine-cert-request
• --reduce-security-for-testing
• --enable-experimental-canvas-features
• --enable-font-antialiasing
• --enable-smooth-scrolling
• --enable-webgl-draft-extensions
• --ignore-gpu-blacklist
• --enable-es3-apis
• --always-authorize-plugins
• --expose-internals-for-testing
• --allow-silent-push
• --enable-async-dns
• --enable-download-resumption
• --enable-spdy4
• --disable-origin-chip
• --javascript-harmony
• --print-to-pdf
• --save-page-as-mhtml
• --repl
• --site-per-process

WebKitX1_OnBrowserReady()

OnBrowserReady event notifies you that CEF3 processes and WebKitX control have been successfully created and the Interprocess Communication Mechanism (IPC) is established. At this point you can define secondary behavioral parameters such as focus control, formatting APIs, script downloading control, etc. but most importantly after OnBrowserReady event you can successfully start loading URLs for browsing or editing.

WebKitX1_OnLoadEnd()

OnLoadEnd event is fired when your URL is completely downloaded. At this point you can enable HTML5 Editing or Preview (Browsing) and set the HTML DOM events you want WebKitX to subclass for every HTML Element on the document. After you receive this event you can start using the Selection and Formatting APIs.

Behavior Configuration IMPORTANT NOTES

Enabling JavaScript 

Please note that in WebKitX downloading script tags is disabled by default because in editor mode JavaScript execution often messes with HTML5 styles, especially if you are using features such as Parallax Scrolling and JavaScript-aided responsive layouts. If you want to download and execute JavaScript you must explicitly enable it using  WebKitX1.DownloadScripts = True in OnBrowserReady() event handler, as illustrated in code fragment below. 

As a side note, in editor edition of WebKitX you can execute JavaScript at run-time using Eval, AddScript, AddCode and ExecuteCommand methods, even if DownloadScripts is false. The key difference is download-time and run-time JavaScript execution and WebKitX DownloadScripts parameter controls download-time JavaScript and not run-time JavaScript.

Setting HTML5 by code at Runtime

WebKitX offers your two ways to load HTML: either by WebKitX.Open() method or by WebKitX.HTML property. Please note that providing a URL is recommended for successfully downloading relative resources such as Images, Style Sheets, Scripts, etc. If however you need to use the WebKitX.HTML property you first need to set a fake-but-valid URL and BaseURL. Chromium Embedded Framework Browser requires a valid URL page before you can inject HTML and/or JavaScript by code at run-time. To do so please use the WebKitX.URL and WebKitX.BaseURL properties before you use the WebKitX.HTML property.

Disabling GPU

In WebKitX GPU Hardware Acceleration is enabled by default. However, there are cases that you might need to host your application in a Virtualized environment such as VMware, Citrix or Virtual Box where GPU emulation is not available. You may disable GPU by handling the OnCreate() event and adding --disable-gpu --disable-webgl --disable-3d-apis --disable-gpu-compositing in CommandLineSwitches and setting Settings.webgl = False.

Setting CEF3 Preferences at Runtime

WebKitX offers GetPreference() and SetPreference() methods to read / modify CEF3 preferences at run-time. Please note that setting preferences causes CEF browser to recreate and it is time-costly, so use it with caution, especially when synchronizing WebKitX HTML with a Code Editor (like HTML5 Pad does). For example to enable / disable Spell Checking, WebKitX uses an internal Boolean latch in order to avoid browser recreation and you should use WebKitX1.SpellChecking = true instead of SetPreference("browser.enable_spellchecking", "true").

For a list of preference please have a look here: https://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/pref_names.cc?view=markup

WebKitX Plugins

WebKitX plugins are disabled by default in both Browser and Editor editions. To enable plugins you need to handle the OnCreate event and set Settings.plugins = True as illustrated below:

PDF Viewer Plugin

When plugins are disabled PDF files will download as regular files rather than render on the screen. To enable PDF Viewer you need to handle the OnCreate event and set Settings.plugins = True.

Flash Player Plugin

To enable Flash player you need to download a x86 version of pepflashplayer.dll and provide the path to it by setting the Settings.flash_player_dll_path property in OnCreate() event, as illustrated below. If you copy the DLL in the ActiveX folder then you do not need to provide the full path. If you decide to install the DLL in a different folder you should provide the path with forward slashes (unix-style paths).

WebKitX is tested with pepflashplayer32_29_0_0_113.dll

Chrome DevTools Plugin

Chrome DevTools is a set of web developer tools built directly into the Google Chrome browser. DevTools can help you diagnose problems quickly, which ultimately helps you build better websites, faster.

Calling JavaScript

Calling JavaScript Functions by Name - 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 for a Specific Execution Context -  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.

Registering JavaScript Callbacks

Each frame in a browser window has its own V8 context. The context defines the scope for all variables, objects and functions defined in that frame. WebKitX allows you to register a JavaScript callback in a V8 context using window.register(name, callback, this) method. The first argument is the string name of the function, the second is the function callback and the 3rd optional parameter is the execution context. If the 3rd parameter is not defined then the global object is assumed.

Invoking JavaScript Callbacks

To invoke the JavaScript callback you simply need to call WebKitX.JSCallback(name, params, async) method passing the name of the JavaScript function you want to invoke and a Variant with the arguments. For critical real-time applications you should set async parameter to True, which executes the IPC call synchronously. The result depends on the JavaScript function and can be either a scalar value or a variant array of variants.

OLE/COM Variants to V8 Values Conversion EXPERIMENTAL

WebKitX has a powerful OLE/COM Variant to Google V8 Value bi-directional converter that works both for Scalar and Array values, including nested array values (arrays of arrays of variants). This conversion mechanism is available to any WebKitX method transmitting and/or returning an OLE/COM Variant, such as CallByName(), JSCallBack() and DispatchEvent().

WebKitX can serialize variant scalars VT_BSTR, VT_UINT, VT_INT, VT_NULL, VT_BOOL, VT_R4, VT_R8, VT_CY, VT_DATE as well as variant safearray of variants VT_ARRAY|VT_VARIANT and even typed arrays VT_ARRAY|VT_BSTR, VT_ARRAY|VT_UINT, VT_ARRAY|VT_INT, VT_ARRAY|VT_BOOL, VT_ARRAY|VT_R4, VT_ARRAY|VT_R8, VT_ARRAY|VT_CY, VT_ARRAY|VT_DATE to Google V8 value objects. Currently serialization of VT_DISPATCH is not supported and therefore you cannot pass OLE/COM Objects to JavaScript.

On the OLE/COM side, to pass multiple arguments to a JavaScript callback function you need to wrap them in a Variant Array of Variants.

On the JavaScript side, you can return V8 Scalar or V8 Array values to OLE/COM side, including nested V8 Arrays. WebKitX can serialize V8 scalar Boolean, Number, String, Null, Date values and Array of [Boolean or Number or String or Null or Date or Array] V8 values. Google V8 Arrays are always returned as Variant Arrays of Variants.

On the receiving OLE/COM side the scalars are converted to a Variant of equivalent scalar type and Arrays are converted into a Variant Array of Variants.

HTML5 DOM to COM Events

Selector based API

Asynchronous DOM to COM 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 DOM to COM Events

WebKitX as of version 1.5.11.2591 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.

Please note that blocking Inter-process Communication (IPC) between 3 processes is not advisable for casual event handling and you should do so only if you need to cancel specific events. Synchronous DOM to COM Events are thread-safe and care has been placed in order to support this feature seamlessly in single-threaded Applications without deadlocks. For that purpose, synchronous events are serialized using mutex synchronization on entry, meaning that synchronous events occupy the IPC channel one at a time. Please contact us for more implementation details or if you need a different handling of DOM to COM events.

Listening to DOM Events

You can use addEventListener and removeEventListener for attaching and detaching on HTML DOM events. WebKitX offers two methods:

• Sub AddEventListener(Selector As String, Event As String, AddressOfEventHandler As Long, UseCapture As Boolean, Async As Boolean) 
  This method expects a Visual Basic 6.0 Sub defined in a public Module (.bas).
• Sub AddEventListenerEx(Selector As String, Event As String, vbObject As Object, vbObjectFunctionName As String, UseCapture As Boolean, Async As Boolean) 
  This method expects a Visual Basic 6.0 Object (Class, Form, Control) and the name of a public Sub.

The signature of the public methods is defined by OnEvent() event which is:

EventData are a JSON string representation of DOM Event:

DOM Events Handling Example

WebKitX Events Sample demonstrates handling DOM events and reading values from Input elements. In the following code fragment are demonstrated the three (3) different methods you can use. The generic method, the AddressOf method that requires a Module, and the IDispatch method that requires an Object. The sample loads a INPUT element and a BUTTON and when you click the button it fires an event which is handled by VB6. The event handler code in VB6 uses WebKitX API to read the value of the INPUT.

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.

WebKitX HTML5 Editor

There are some best practices when using WebKitX as an HTML5 Editor:

Disabling JavaScript download

Disabling scripts downloading is advisable when using WebKitX as an Editor because JavaScript execution often messes with HTML5 styles, especially if you are using features such as Parallax Scrolling and JavaScript-aided responsive layouts.

Detecting Edit Mode from JavaScript

There are cases where your JavaScript code might need to detect if WebKitX is in Edit mode. To do that simply read window.__WEBKITX_EDITABLE__ variable. You should wrap Google Analytics and Google Tags Manager initialization code inside a conditional block and download Google scripts (or any other script) by URL, as illustrated below:

Getting HTML Source

To retrieve HTML5 source as a String you can use WebKitX.HTML property. 

Getting XHTML Source

You can configure WebKitX to return XHTML instead of HTML by setting Settings.enable_xml_html = true in OnCreate() event handler. This setting enables DOM parsing by XMLSerializer that trans-codes your HTML into XML. The output results in better structured and faster parsed documents but XMLSerializer also encodes the source code of <script> elements; in particular  XMLSerializer HTML-Encodes any Entity Character such as ampersand (&) to &amp;, less than (<) to &lt;, grater than (>) to &gt;, etc. You should make sure that all your <script> elements are referenced and not embedded.

Using WebKitX with MDI Forms

MDI Forms in most programming languages suffer from flickering effects. When using WebKitX in an MDI child Form, you may notice rendering problems when MDI children overlap each other during resizing or moving. To treat this problem you need to add WebKitX.SetMDIWindow(hWND) in every MDI child Form that uses WebKitX control. The call installs a window sub-class hook that detects WM_WINDOWPOSCHANGING and  WM_MOVING messages and repaints the entire MDI Form. In order to avoid further flickering and redundant repaints, WebKitX uses Timer that absorbs repeated WM_WINDOWPOSCHANGING and WM_MOVING messages. For SetMDIWindow() to work, the WebKitX control must be directly placed inside an MDI Child Form and must not be contained inside another control (such as a TabStrip).

Overlapping Form Controls (re-positioning / re-z-indexing)

When you place WebKitX control inside a TabStrip control you must control its Visibility in order to avoid rendering problems. Most TabStrip controls during page selection, instead of toggling the visibility of the pages and/or their contained controls, they simply re-position the inactive controls in a non-visible area or re-position the controls along the z-axis. However, CEF3 window is an out-of-process overlay window on-top of WebKitX COleControl window and re-positioning or re-z-indexing form controls can cause rendering problems to WebKitX and other controls in your form too.

To avoid this problem as of version 1.5.11.3370 WebKitX does not resize/re-position CEF3 browser window if WebKitX control is invisible (WebKitX.Visible = False). However, there is a best practice you must follow in order to achieve the desired behavior: you need to control WebKitX visibility by code, as illustrated below. Also, we have added WebKitX.SetAutoResize(Enable) method to explicitly enable or disable CEF3 resize/re-position. Please note that to force WebKitX / CEF3 to resize/re-position after they become visible again, you must call WebKitX.Repaint() method.

The problem described does not appear only with TabStrip controls; the same defect appears if you have custom control layouting implementation in your Forms that re-positions controls or re-indexes controls z-index.

Content Filtering EXPERIMENTAL

UNSUPPORTED EXPERIMENTAL FEATURE

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.

Overwrite Cross-Origin Resource Sharing (CORS)

Cross-Origin Resource Sharing (CORS) is a mechanism that uses additional HTTP headers to tell a browser to let a web application running at one origin (domain) have permission to access selected resources from a server at a different origin. A web application makes a cross-origin HTTP request when it requests a resource that has a different origin (domain, protocol, and port) than its own origin.

An example of a cross-origin request: The frontend JavaScript code for a web application served from http://domain-a.com uses XMLHttpRequest to make a request for http://api.domain-c.com/data.json.

For security reasons, browsers restrict cross-origin HTTP requests initiated from within scripts. For example, XMLHttpRequest and the Fetch API follow the same-origin policy. This means that a web application using those APIs can only request HTTP resources from the same origin the application was loaded from, unless the response from the other origin includes the right CORS headers.

The CORS mechanism supports secure cross-origin requests and data transfers between browsers and web servers. Modern browsers use CORS in an API container such as XMLHttpRequest or Fetch to help mitigate the risks of cross-origin HTTP requests.

This cross-origin sharing standard is used to enable cross-site HTTP requests for:

• Invocations of the XMLHttpRequest
• Web Fonts (for cross-domain font usage in @font-face within CSS)
• WebGL textures
• Images/video frames drawn to a canvas using drawImage()
• Stylesheets (for CSSOM access)
• Scripts (for unmuted exceptions)

To enable CORS, you need to configure your web server to return the Access-Control-Allow-Origin HTTP header:
Access-Control-Allow-Origin: *
Access-Control-Allow-Origin: <origin>

In WebKitX you can overwrite web server's Access-Control-Allow-Origin  by handling the OnCreate() event and setting Settings.filter_response = true and Settings.access_control_allow_origin to "*" or the domain you wish to allow.

Overwrite Content Security Policy (CSP)

WebKitX due to JavaScript injection features and extensive use of eval(), both in Browser and Editor editions, requires Content Security Policy (CSP) to be suppressed. If you try to load a URL with CSP enabled in WebKitX, it will result in a series of error messages related to unsafe-eval, like the one below:

Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, including Cross Site Scripting (XSS) and data injection attacks. These attacks are used for everything from data theft to site defacement or distribution of malware. CSP is designed to be fully backward compatible. Browsers that don't support it still work with servers that implement it, and vice-versa: browsers that don't support CSP simply ignore it, functioning as usual, defaulting to the standard same-origin policy for web content. If the site doesn't offer the CSP header, browsers likewise use the standard same-origin policy.

To enable CSP, you need to configure your web server to return the Content-Security-Policy HTTP header (sometimes you will see mentions of the X-Content-Security-Policy header, but that's an older version and you don't need to specify it anymore).

In WebKitX you can overwrite web server's Content-Security-Policy by handling the OnCreate() event and setting Settings.filter_response = true and Settings.remove_response_headers to "x-webkit-csp,content-security-policy,x-content-security-policy". The same feature can be used to remove any other response header.

Some sites stop loading after enabling Content Filtering

WebKitX Content Filtering features and SSL Client Certificate enabled on your Web Server cannot work together. You must either disable WebKitX Content Filtering or disable SSL Client Certificate on your Web Server, as illustrated below:

Page Encoding problems with early implementation of Content Filtering

CEF 3.3202.1692 ignores Content-Type charset option when using custom CefResourceHandler, causing pages such as Google.gr or Google.de to render with unreadable characters. [bug link]. To treat this problem, WebKitX Content Filtering enforces UTF-8 BOM insertion in text/plain, text/html, application/json, application/javascript, application/ecmascript, text/css, text/xml MIME types. Please note that the bug appears only if content filtering is enabled and does not affect normal (unfiltered) browsing or editing. The plan about this bug is to switch to newer version of CEF3 on January 2019.

Loading www.google.gr with content filtering with version 1.5.11.3220:

Loading www.google.gr with content filtering with version 1.5.11.3297 (Sep 2018) and later:

General Trouble Shooting IMPORTANT NOTES

WebKitX installation Fails

If during WebKitX installation you get an error message that WebKitXCEF3.ocx and cmax40.dll failed to register, it most certainly means that  Microsoft x86 C++ 2015 Redistributable Package failed to automatically install because the Windows OS version and/or its current Service Pack are not compatible with the included Microsoft x86 C++ 2015 Redistributable Package. You are advised to download Microsoft x86 C++ 2015 Redistributable Package for you Operating System and Service Pack bundle, and install it manually, from here: Microsoft Visual C++ 2015 Redistributable Update 3 RC.

Nothing Paints on my Form

WebKitX ActiveX provides OLE Control Host Window Handle (HWND) to Chromium Embedded Framework (CEF3), which in turn paints the HTML5 composite image to the OLE Control Host Device Context (HDC). This mechanism requires you to Disable Double Buffering Features of the Host Form or OLE Control Host. Furthermore please make sure you set the scale mode of your Host Form or OLE Control Host to Pixels.

I get unsafe-eval error messages

WebKitX due to JavaScript injection features and extensive use of Eval(), both in Browser and Editor editions, requires Content Security Policy (CSP) to be suppressed. If you try to load a site with CSP enabled in WebKitX, it will result in a series of error messages related to unsafe-eval. Please refer to Content Filtering article above for information how to by-pass CSP in WebKitX.

My Web Site does not load

WebKitX Content Filtering features and SSL Client Certificate enabled on your Web Server cannot work together, by design. You must either disable WebKitX Content Filtering or disable SSL Client Certificate on your Web Server. Please note this has nothing to do with HTTPS. For more information please refer to Content Filtering chapter.

WebKitX COM Interfaces

// WebKitXCEF3.idl : type library source for ActiveX Control project.

// This file will be processed by the MIDL compiler tool to
#include <olectl.h>
#include <idispids.h>

import "ocidl.idl";
import "oaidl.idl";

[
	uuid(316AC43B-854D-415B-AC7D-637569B2D263),
	version(1.0),
	control,
	helpstring("mobileFX WebKitX CEF3 ActiveX")
]
library WebKitXCEF3Lib
{
	importlib(STDOLE_TLB);

	typedef enum DOM_EVENTS
	{
		DOM_EVENT_NONE							= 0,
		DOM_EVENT_CLICK							= 1,
		DOM_EVENT_DBLCLICK						= 2,
		DOM_EVENT_MOUSE_DOWN					= 4,
		DOM_EVENT_MOUSE_MOVE					= 8,
		DOM_EVENT_MOUSE_UP						= 16,
		DOM_EVENT_KEY_DOWN						= 32,
		DOM_EVENT_KEY_PRESS						= 64,
		DOM_EVENT_KEY_UP						        = 128,
		DOM_EVENT_CUT							= 256,
		DOM_EVENT_COPY							= 512,
		DOM_EVENT_PASTE							= 1024,
		DOM_EVENT_SELECT						        = 2048,
		DOM_EVENT_SELECTSTART					= 4096,
		DOM_EVENT_SELECTION_CHANGE				= 8192,
		DOM_EVENT_DOMFOCUSIN					= 16384,
		DOM_EVENT_DOMFOCUSOUT					= 32768,
		DOM_EVENT_DOMNODEINSERTED				= 65536,
		DOM_EVENT_DOMNODEREMOVED				= 131072,
		DOM_EVENT_DOMNODEINSERTEDINTODOCUMENT	= 262144,
		DOM_EVENT_DOMNODEREMOVEDFROMDOCUMENT	= 524288,
		DOM_EVENT_DOMSUBTREEMODIFIED			        = 1048576,
		DOM_EVENT_DOMCHARACTERDATAMODIFIED		= 2097152,
		DOM_EVENT_EDITABLE_ELEMENT_CHANGED		= 4194304,

	} DOM_EVENTS;

	typedef enum EVENT_CONSTRUCTORS
	{
		CustomEvent = 0,
		AnimationEvent,
		AudioProcessingEvent,
		BeforeInputEvent,
		BeforeUnloadEvent,
		BlobEvent,
		ClipboardEvent,
		CloseEvent,
		CompositionEvent,
		CSSFontFaceLoadEvent,
		DeviceLightEvent,
		DeviceMotionEvent,
		DeviceOrientationEvent,
		DeviceProximityEvent,
		DOMTransactionEvent,
		DragEvent,
		EditingBeforeInputEvent,
		ErrorEvent,
		FetchEvent,
		FocusEvent,
		GamepadEvent,
		HashChangeEvent,
		IDBVersionChangeEvent,
		InputEvent,
		KeyboardEvent,
		MediaStreamEvent,
		MessageEvent,
		MouseEvent,
		MutationEvent,
		OfflineAudioCompletionEvent,
		PageTransitionEvent,
		PointerEvent,
		PopStateEvent,
		ProgressEvent,
		RelatedEvent,
		RTCDataChannelEvent,
		RTCIdentityErrorEvent,
		RTCIdentityEvent,
		RTCPeerConnectionIceEvent,
		SensorEvent,
		StorageEvent,
		SVGEvent,
		SVGZoomEvent,
		TimeEvent,
		TouchEvent,
		TrackEvent,
		TransitionEvent,
		UIEvent,
		UserProximityEvent,
		WebGLContextEvent,
		WheelEvent,
	} EVENT_CONSTRUCTORS;


	typedef enum DOM_NODE_TYPES
	{
		DOM_NODE_TYPE_UNSUPPORTED = 0,
		DOM_NODE_TYPE_ELEMENT,
		DOM_NODE_TYPE_ATTRIBUTE,
		DOM_NODE_TYPE_TEXT,
		DOM_NODE_TYPE_CDATA_SECTION,
		DOM_NODE_TYPE_PROCESSING_INSTRUCTIONS,
		DOM_NODE_TYPE_COMMENT,
		DOM_NODE_TYPE_DOCUMENT,
		DOM_NODE_TYPE_DOCUMENT_TYPE,
		DOM_NODE_TYPE_DOCUMENT_FRAGMENT,
	} DOM_NODE_TYPES;

	typedef enum NAV_RESOURCE_TYPE
	{
		RT_MAIN_FRAME = 0,
		RT_SUB_FRAME,
		RT_STYLESHEET,
		RT_SCRIPT,
		RT_IMAGE,
		RT_FONT_RESOURCE,
		RT_SUB_RESOURCE,
		RT_OBJECT,
		RT_MEDIA,
		RT_WORKER,
		RT_SHARED_WORKER,
		RT_PREFETCH,
		RT_FAVICON,
		RT_XHR,
		RT_PING,
		RT_SERVICE_WORKER,
		RT_CSP_REPORT,
		RT_PLUGIN_RESOURCE,
	} NAV_RESOURCE_TYPE;

	typedef enum NAV_TRANSITION_TYPE 
	{
		TT_LINK = 0,
		TT_EXPLICIT = 1,
		TT_AUTO_SUBFRAME = 3,
		TT_MANUAL_SUBFRAME = 4,
		TT_FORM_SUBMIT = 7,
		TT_RELOAD = 8,
		TT_SOURCE_MASK = 0xFF,
		TT_BLOCKED_FLAG = 0x00800000,
		TT_FORWARD_BACK_FLAG = 0x01000000,
		TT_CHAIN_START_FLAG = 0x10000000,
		TT_CHAIN_END_FLAG = 0x20000000,
		TT_CLIENT_REDIRECT_FLAG = 0x40000000,
		TT_SERVER_REDIRECT_FLAG = 0x80000000,
		TT_IS_REDIRECT_MASK = 0xC0000000,
		TT_QUALIFIER_MASK = 0xFFFFFF00,
	} NAV_TRANSITION_TYPE;

	typedef enum EDIT_COMMANDS
	{
		EDIT_CMD_BACKCOLOR,
		EDIT_CMD_BOLD,
		EDIT_CMD_CONTENTREADONLY,
		EDIT_CMD_COPY,
		EDIT_CMD_CREATELINK,
		EDIT_CMD_CUT,
		EDIT_CMD_DECREASEFONTSIZE,
		EDIT_CMD_DELETE,
		EDIT_CMD_ENABLEINLINETABLEEDITING,
		EDIT_CMD_ENABLEOBJECTRESIZING,
		EDIT_CMD_FONTNAME,
		EDIT_CMD_FONTSIZE,
		EDIT_CMD_FORECOLOR,
		EDIT_CMD_FORMATBLOCK,
		EDIT_CMD_FORWARDDELETE,
		EDIT_CMD_HEADING,
		EDIT_CMD_HILITECOLOR,
		EDIT_CMD_INCREASEFONTSIZE,
		EDIT_CMD_INDENT,
		EDIT_CMD_INSERTBRONRETURN,
		EDIT_CMD_INSERTHORIZONTALRULE,
		EDIT_CMD_INSERTHTML,
		EDIT_CMD_INSERTIMAGE,
		EDIT_CMD_INSERTORDEREDLIST,
		EDIT_CMD_INSERTUNORDEREDLIST,
		EDIT_CMD_INSERTPARAGRAPH,
		EDIT_CMD_INSERTTEXT,
		EDIT_CMD_ITALIC,
		EDIT_CMD_JUSTIFYCENTER,
		EDIT_CMD_JUSTIFYFULL,
		EDIT_CMD_JUSTIFYLEFT,
		EDIT_CMD_JUSTIFYRIGHT,
		EDIT_CMD_OUTDENT,
		EDIT_CMD_PASTE,
		EDIT_CMD_REDO,
		EDIT_CMD_REMOVEFORMAT,
		EDIT_CMD_SELECTALL,
		EDIT_CMD_STRIKETHROUGH,
		EDIT_CMD_SUBSCRIPT,
		EDIT_CMD_SUPERSCRIPT,
		EDIT_CMD_UNDERLINE,
		EDIT_CMD_UNDO,
		EDIT_CMD_UNLINK,
		EDIT_CMD_UNSELECT,
		EDIT_CMD_USECSS,
		EDIT_CMD_STYLEWITHCSS,

		// CEFX	- Table
		EDIT_CMD_TABLE_INSERT,
		EDIT_CMD_TABLE_DELETE,
		EDIT_CMD_TABLE_INSERT_ROW,
		EDIT_CMD_TABLE_INSERT_COL,
		EDIT_CMD_TABLE_REMOVE_ROW,
		EDIT_CMD_TABLE_REMOVE_COL,
		EDIT_CMD_TABLE_MERGE,
		EDIT_CMD_TABLE_SPLIT_HORIZ,
		EDIT_CMD_TABLE_SPLIT_VERT,

		// CEFX - Selection
		EDIT_CMD_SEL_GET_TYPE,
		EDIT_CMD_SEL_GET_COLLAPSED,
		EDIT_CMD_SEL_GET_CONTAINS_NODE,

		EDIT_CMD_SEL_GET_HTML,
		EDIT_CMD_SEL_SET_HTML, 
		
		EDIT_CMD_SEL_GET_TEXT,		
		EDIT_CMD_SEL_SET_TEXT,

		EDIT_CMD_SEL_GET_FONT_NAME,
		EDIT_CMD_SEL_GET_FONT_SIZE,
		EDIT_CMD_SEL_GET_FONT_COLOR,
		EDIT_CMD_SEL_GET_FONT_BACK_COLOR,
		EDIT_CMD_SEL_GET_FONT_STYLE,
		EDIT_CMD_SEL_GET_FONT_BOLD,
		EDIT_CMD_SEL_GET_FONT_ITALIC,
		EDIT_CMD_SEL_GET_FONT_UNDERLINE,
		EDIT_CMD_SEL_GET_FONT_STRIKETHROUGH,

		EDIT_CMD_SEL_SET_FONT_NAME,
		EDIT_CMD_SEL_SET_FONT_SIZE,
		EDIT_CMD_SEL_SET_FONT_COLOR,
		EDIT_CMD_SEL_SET_FONT_BACK_COLOR,		
		EDIT_CMD_SEL_SET_FONT_BOLD,
		EDIT_CMD_SEL_SET_FONT_ITALIC,
		EDIT_CMD_SEL_SET_FONT_UNDERLINE,
		EDIT_CMD_SEL_SET_FONT_STRIKETHROUGH,
		
		EDIT_CMD_SEL_COLLAPSE_TO_END,
		EDIT_CMD_SEL_COLLAPSE_TO_START,
		EDIT_CMD_SEL_DELETE,
		EDIT_CMD_SEL_EMPTY,
		EDIT_CMD_SEL_EXTEND,
		EDIT_CMD_SEL_ALL_CHILDREN,

		// CEFX Other
		EDIT_CMD_GET_URL,

	} EDIT_COMMANDS;

	[
		object,
		uuid(9B527943-9DF8-479A-8BE7-DEBF8BBD5A42),
		helpstring("mobileFX WebKitX for CEF3"),
		dual,
		nonextensible,
		pointer_default(unique)
	]
	interface ISettings : IDispatch
	{
		[propget, id(2)] HRESULT accept_language_list([out, retval] BSTR* pVal);
		[propput, id(2)] HRESULT accept_language_list([in] BSTR newVal);
		[propget, id(3)] HRESULT cache_path([out, retval] BSTR* pVal);
		[propput, id(3)] HRESULT cache_path([in] BSTR newVal);
		[propget, id(4)] HRESULT command_line_args_disabled([out, retval] LONG* pVal);
		[propput, id(4)] HRESULT command_line_args_disabled([in] LONG newVal);
		[propget, id(5)] HRESULT enable_net_security_expiration([out, retval] LONG* pVal);
		[propput, id(5)] HRESULT enable_net_security_expiration([in] LONG newVal);
		[propget, id(6)] HRESULT framework_dir_path([out, retval] BSTR* pVal);
		[propput, id(6)] HRESULT framework_dir_path([in] BSTR newVal);
		[propget, id(7)] HRESULT ignore_certificate_errors([out, retval] LONG* pVal);
		[propput, id(7)] HRESULT ignore_certificate_errors([in] LONG newVal);
		[propget, id(8)] HRESULT javascript_flags([out, retval] BSTR* pVal);
		[propput, id(8)] HRESULT javascript_flags([in] BSTR newVal);
		[propget, id(9)] HRESULT locale([out, retval] BSTR* pVal);
		[propput, id(9)] HRESULT locale([in] BSTR newVal);
		[propget, id(10)] HRESULT locales_dir_path([out, retval] BSTR* pVal);
		[propput, id(10)] HRESULT locales_dir_path([in] BSTR newVal);
		[propget, id(11)] HRESULT log_file([out, retval] BSTR* pVal);
		[propput, id(11)] HRESULT log_file([in] BSTR newVal);
		[propget, id(12)] HRESULT persist_session_cookies([out, retval] LONG* pVal);
		[propput, id(12)] HRESULT persist_session_cookies([in] LONG newVal);
		[propget, id(13)] HRESULT persist_user_preferences([out, retval] LONG* pVal);
		[propput, id(13)] HRESULT persist_user_preferences([in] LONG newVal);
		[propget, id(14)] HRESULT remote_debugging_port([out, retval] LONG* pVal);
		[propput, id(14)] HRESULT remote_debugging_port([in] LONG newVal);
		[propget, id(15)] HRESULT resources_dir_path([out, retval] BSTR* pVal);
		[propput, id(15)] HRESULT resources_dir_path([in] BSTR newVal);
		[propget, id(16)] HRESULT uncaught_exception_stack_size([out, retval] LONG* pVal);
		[propput, id(16)] HRESULT uncaught_exception_stack_size([in] LONG newVal);
		[propget, id(17)] HRESULT user_agent([out, retval] BSTR* pVal);
		[propput, id(17)] HRESULT user_agent([in] BSTR newVal);
		[propget, id(18)] HRESULT user_data_path([out, retval] BSTR* pVal);
		[propput, id(18)] HRESULT user_data_path([in] BSTR newVal);
		[propget, id(19)] HRESULT application_cache([out, retval] BSTR* pVal);
		[propput, id(19)] HRESULT application_cache([in] BSTR newVal);
		[propget, id(20)] HRESULT cursive_font_family([out, retval] BSTR* pVal);
		[propput, id(20)] HRESULT cursive_font_family([in] BSTR newVal);
		[propget, id(21)] HRESULT background_color([out, retval] OLE_COLOR* pVal);
		[propput, id(21)] HRESULT background_color([in] OLE_COLOR newVal);
		[propget, id(22)] HRESULT databases([out, retval] VARIANT_BOOL* pVal);
		[propput, id(22)] HRESULT databases([in] VARIANT_BOOL newVal);
		[propget, id(23)] HRESULT default_encoding([out, retval] BSTR* pVal);
		[propput, id(23)] HRESULT default_encoding([in] BSTR newVal);
		[propget, id(24)] HRESULT default_fixed_font_size([out, retval] LONG* pVal);
		[propput, id(24)] HRESULT default_fixed_font_size([in] LONG newVal);
		[propget, id(25)] HRESULT default_font_size([out, retval] LONG* pVal);
		[propput, id(25)] HRESULT default_font_size([in] LONG newVal);
		[propget, id(26)] HRESULT fantasy_font_family([out, retval] BSTR* pVal);
		[propput, id(26)] HRESULT fantasy_font_family([in] BSTR newVal);
		[propget, id(27)] HRESULT file_access_from_file_urls([out, retval] VARIANT_BOOL* pVal);
		[propput, id(27)] HRESULT file_access_from_file_urls([in] VARIANT_BOOL newVal);
		[propget, id(28)] HRESULT fixed_font_family([out, retval] BSTR* pVal);
		[propput, id(28)] HRESULT fixed_font_family([in] BSTR newVal);
		[propget, id(29)] HRESULT image_loading([out, retval] VARIANT_BOOL* pVal);
		[propput, id(29)] HRESULT image_loading([in] VARIANT_BOOL newVal);
		[propget, id(30)] HRESULT image_shrink_standalone_to_fit([out, retval] VARIANT_BOOL* pVal);
		[propput, id(30)] HRESULT image_shrink_standalone_to_fit([in] VARIANT_BOOL newVal);
		[propget, id(31)] HRESULT javascript([out, retval] VARIANT_BOOL* pVal);
		[propput, id(31)] HRESULT javascript([in] VARIANT_BOOL newVal);
		[propget, id(32)] HRESULT javascript_access_clipboard([out, retval] VARIANT_BOOL* pVal);
		[propput, id(32)] HRESULT javascript_access_clipboard([in] VARIANT_BOOL newVal);
		[propget, id(33)] HRESULT local_storage([out, retval] VARIANT_BOOL* pVal);
		[propput, id(33)] HRESULT local_storage([in] VARIANT_BOOL newVal);
		[propget, id(34)] HRESULT minimum_font_size([out, retval] LONG* pVal);
		[propput, id(34)] HRESULT minimum_font_size([in] LONG newVal);
		[propget, id(35)] HRESULT minimum_logical_font_size([out, retval] LONG* pVal);
		[propput, id(35)] HRESULT minimum_logical_font_size([in] LONG newVal);
		[propget, id(36)] HRESULT plugins([out, retval] VARIANT_BOOL* pVal);
		[propput, id(36)] HRESULT plugins([in] VARIANT_BOOL newVal);
		[propget, id(37)] HRESULT remote_fonts([out, retval] VARIANT_BOOL* pVal);
		[propput, id(37)] HRESULT remote_fonts([in] VARIANT_BOOL newVal);
		[propget, id(38)] HRESULT sans_serif_font_family([out, retval] BSTR* pVal);
		[propput, id(38)] HRESULT sans_serif_font_family([in] BSTR newVal);
		[propget, id(39)] HRESULT serif_font_family([out, retval] BSTR* pVal);
		[propput, id(39)] HRESULT serif_font_family([in] BSTR newVal);
		[propget, id(40)] HRESULT standard_font_family([out, retval] BSTR* pVal);
		[propput, id(40)] HRESULT standard_font_family([in] BSTR newVal);
		[propget, id(41)] HRESULT tab_to_links([out, retval] VARIANT_BOOL* pVal);
		[propput, id(41)] HRESULT tab_to_links([in] VARIANT_BOOL newVal);
		[propget, id(42)] HRESULT text_area_resize([out, retval] VARIANT_BOOL* pVal);
		[propput, id(42)] HRESULT text_area_resize([in] VARIANT_BOOL newVal);
		[propget, id(43)] HRESULT universal_access_from_file_urls([out, retval] VARIANT_BOOL* pVal);
		[propput, id(43)] HRESULT universal_access_from_file_urls([in] VARIANT_BOOL newVal);
		[propget, id(44)] HRESULT web_security([out, retval] VARIANT_BOOL* pVal);
		[propput, id(44)] HRESULT web_security([in] VARIANT_BOOL newVal);
		[propget, id(45)] HRESULT webgl([out, retval] VARIANT_BOOL* pVal);
		[propput, id(45)] HRESULT webgl([in] VARIANT_BOOL newVal);
		[propget, id(46)] HRESULT javascript_close_windows([out, retval] VARIANT_BOOL* pVal);
		[propput, id(46)] HRESULT javascript_close_windows([in] VARIANT_BOOL newVal);
		[propget, id(47)] HRESULT javascript_dom_paste([out, retval] VARIANT_BOOL* pVal);
		[propput, id(47)] HRESULT javascript_dom_paste([in] VARIANT_BOOL newVal);
		[propget, id(48)] HRESULT flash_player_dll_path([out, retval] BSTR* pVal);
		[propput, id(48)] HRESULT flash_player_dll_path([in] BSTR newVal);

		[id(255)] HRESULT toString([out, retval] BSTR* str);
	};


	[ 
		uuid(0A76D3F3-A67A-4267-AB1C-884DD2CAF047)	
	]
	dispinterface _DWebKitXCEF3
	{
		properties:

			// IPC

			[id(100)] LONG IPC_TIMEOUT_MILLIS;
			
			// HTML5 Editing
						
			[id(9)] VARIANT_BOOL Modified;

			// DOM Events

			[id(15)] DOM_EVENTS Events;
			[id(106)] VARIANT_BOOL ASYNC_EVENTS;
			[id(107)] VARIANT_BOOL FireOnEventForAllEvents;

			// Navigation
			
			[id(80)] VARIANT_BOOL BrowserReady; 
			[id(10)] BSTR HTML;
			[id(64)] BSTR URL;
			[id(77)] BSTR BaseURL;
			[id(76)] BSTR CurrentURL;

			[id(16)] OLE_HANDLE hWnd;
			[id(17)] OLE_HANDLE hWndBrowser;

			// HTML5 Editing - Selection
			
			[id(20)] BSTR ActiveElement;			
			[id(25)] BSTR SelAnchorElement;
			[id(26)] BSTR SelFocusElement;

			[id(32)] BSTR SelHTML;
			[id(33)] BSTR SelFontName;
			[id(34)] BSTR SelFontSize;
			[id(35)] BSTR SelFontColor;
			[id(36)] BSTR SelFontBackColor;			
			[id(38)] BSTR SelText;
			[id(39)] BSTR SelType;

			[id(40)] VARIANT_BOOL SelCollapsed;
			[id(49)] VARIANT_BOOL SelFontBold;
			[id(50)] VARIANT_BOOL SelFontItalic;
			[id(51)] VARIANT_BOOL SelStrikeThrough;
			[id(52)] VARIANT_BOOL SelFontUnderline;
			[id(54)] VARIANT_BOOL ExecCommandSetFocus;
			[id(55)] VARIANT_BOOL SpellChecking;

			[id(56)] VARIANT_BOOL FormatUsingInternalSelectionAPI;

			// Data-Binding (WIP)
			
			[id(71)] BSTR DataSource;
			[id(72)] BSTR DataMember;			
			[id(95)] BSTR DataField;

			// HTML5 Editing - Undo / Redo

			[id(96)] VARIANT_BOOL UndoEnabled;
			[id(85)] LONG UndoSize;
			[id(87)] VARIANT_BOOL CanUndo;
			[id(88)] VARIANT_BOOL CanRedo;
			[id(89)] LONG RedoSize;
			[id(90)] VARIANT_BOOL UndoObserverEnabled;

			// Download Files
			
			[id(91)] VARIANT_BOOL DownloadScripts;			

		methods:

			// Creation / Activation

			[id(79)] void Create();
			[id(81)] void Repaint();
			[id(31)] VARIANT_BOOL Activate(BSTR YourEmail, BSTR YourActivationKey);
			[id(108)] VARIANT_BOOL ActivateTerminal(BSTR YourTerminalActivationKey);

			// Chrome Dev Tools
			[id(99)] void ShowDevTools();

			// Preferences

			[id(69)] BSTR GetPreference(BSTR Name);
			[id(70)] void SetPreference(BSTR Name, BSTR Value);

			// Navigation

			[id(1)] void Open(BSTR URL); 
			[id(92)] void NavigateBack();
			[id(93)] void NavigateForward();
			[id(94)] void StopLoading();

			// JavaScript (Editor Edition Only)

			[id(97)] void AddScript(BSTR URL);
			[id(98)] void AddCode(BSTR JavaScript);
			[id(4)] BSTR Eval(BSTR Code);			
			[id(103)] VARIANT JSCallback(BSTR FunctionName, VARIANT Arguments, VARIANT_BOOL Async);
			[id(105)] VARIANT CallByName(BSTR Name, VARIANT Arguments);

			// DOM Events
			
			[id(5)] void AddEventListener(BSTR Selector, BSTR Event, LONG AddressOfEventHandler, VARIANT_BOOL UseCapture, VARIANT_BOOL Async);
			[id(6)] void AddEventListenerEx(BSTR Selector, BSTR Event, IDispatch* vbObject, BSTR vbObjectFunctionName, VARIANT_BOOL UseCapture, VARIANT_BOOL Async);			
			[id(18)] void RemoveEventListener(BSTR Selector, BSTR Event, LONG AddressOfEventHandler, VARIANT_BOOL UseCapture);
			[id(19)] void RemoveEventListenerEx(BSTR Selector, BSTR Event, IDispatch* vbObject, BSTR vbObjectFunctionName, VARIANT_BOOL UseCapture);
			[id(104)] VARIANT DispatchEvent(BSTR TargetSelector, BSTR EventName, VARIANT_BOOL Bubbles, VARIANT_BOOL Cancelable, VARIANT_BOOL Composed, VARIANT Detail, VARIANT_BOOL Async);

			// DOM Access - Attributes

			[id(59)] BSTR GetAttributes(BSTR Selector);
			[id(60)] void SetAttributes(BSTR Selector, BSTR Attributes);
			[id(74)] void RemoveAttribute(BSTR Selector, BSTR AttrName);
			[id(11)] void SetAttribute(BSTR Selector, BSTR Name, BSTR Value);
			[id(13)] BSTR GetAttribute(BSTR Selector, BSTR AttrName);

			// DOM Access - CSS3 / Styles

			[id(58)] BSTR GetStyle(BSTR Selector, BSTR Setting, VARIANT_BOOL ComputedStyle);
			[id(8)] void SetStyle(BSTR Selector, BSTR Setting, BSTR Value);
			[id(14)] BSTR GetCssText(BSTR Selector, VARIANT_BOOL ComputedStyle);
			[id(57)] void SetCssText(BSTR Selector, BSTR CSSText);

			// DOM Access - HTML Markup

			[id(21)] BSTR GetInnerHTML(BSTR Selector);
			[id(22)] void SetInnerHTML(BSTR Selector, BSTR HTML);
			[id(23)] BSTR GetOuterHTML(BSTR Selector);
			[id(24)] void SetOuterHTML(BSTR Selector, BSTR HTML);

			// HTML5 Editing

			[id(2)] void Edit();
			[id(3)] void Preview();
			[id(27)] BSTR ExecCommand(EDIT_COMMANDS Command, BSTR Selector, BSTR Arguments);
			[id(28)] BSTR TidyHTML(BSTR HTML, BSTR Options);
			[id(63)] void ReplaceText(BSTR Find, BSTR Replace, VARIANT_BOOL IgnoreCase);

			// HTML5 Editing - Selection

			[id(7)] void SelectElement(BSTR Selector, VARIANT_BOOL MoveCaret, VARIANT_BOOL SelectContents);
			[id(53)] void Deselect();
			[id(42)] void SelCollapseToEnd();
			[id(43)] void SelCollapseToStart();
			[id(44)] VARIANT_BOOL SelContainsNode(BSTR Selector, VARIANT_BOOL PartialContainment);
			[id(45)] void SelDelete();
			[id(46)] void SelEmpty();
			[id(47)] void SelExtend(BSTR Selector, LONG Offset);
			[id(48)] void SelAllChildren();
			[id(75)] void SelectTableColumn(BSTR TDSelector);
			[id(67)] void Delete(BSTR Selector);
			[id(66)] void SetSelection(LONG Offset, LONG Length);			
			[id(68)] void GetSelection(BSTR Selector, LONG* Offset, LONG* Length);

			// HTML5 Editing - Undo / Redo

			[id(83)] LONG Undo();
			[id(84)] void ClearUndo();
			[id(86)] LONG Redo();
			[id(82)] LONG Commit();

			// Download Files

			[id(101)] void CancelDownload(LONG ID);
			[id(102)] void Download(BSTR URL);			

			// Printing / Saving

			[id(65)] void Print();
			[id(78)] void SaveHTML(BSTR FileName);
			[id(109)] void SavePDF(BSTR FileName, VARIANT_BOOL Landscape);

			// Data-Binding (WIP)

			[id(73)] void DataBind(BSTR Selector);			
          };

	//  Event dispatch interface for CWebKitXCEF3Ctrl

	[ 
		uuid(745E887A-EF5D-4F67-A211-AFA70BDA4A9E)	
	]
	dispinterface _DWebKitXCEF3Events
	{
		properties:
			//  Event interface has no properties

		methods:
			[id(1)] void OnBrowserReady();
			[id(2)] void OnLoadStart();
			[id(3)] void OnLoadEnd();
			[id(4)] void OnLoadError(LONG ErrorCode, BSTR ErrorMessage, BSTR FailedURL);
			[id(5)] void OnLoadingStateChange(VARIANT_BOOL IsLoading, VARIANT_BOOL CanGoBack, VARIANT_BOOL CanGoForward);
			[id(6)] void OnAddressChange(BSTR URL);
			[id(7)] void OnTitleChange(BSTR Title);
			[id(8)] void OnStatusChange(BSTR StatusText);
			[id(9)] void OnConsoleMessage(BSTR ConsoleMessage, BSTR Source, LONG Line);			
			[id(10)] void OnTooltip(BSTR Tip);
			[id(11)] void OnFullscreenModeChange(BSTR Mode);			
			[id(13)] void OnDeselect();						
			[id(15)] void OnUndo(BSTR HTML);
			[id(16)] void OnRedo(BSTR HTML);						
			[id(17)] void OnUndoSave();
			[id(18)] void OnScriptResourceCancelled(BSTR URL);
			[id(19)] void OnContextMenu();			
			[id(20)] void OnComPostMessage(VARIANT* Params);						
			[id(21)] void OnCreate(ISettings* Settings, BSTR* CommandLineSwitches);
			[id(22)] void OnIPCTimeOut();
			[id(23)] void OnBeforeDownload(LONG ID, BSTR URL, BSTR OriginalUrl, BSTR MimeType, BSTR* FullPath, BSTR* SuggestedFileName, LONG TotalBytes, LONG ReceivedBytes, LONG PercentComplete, LONG CurrentSpeed, VARIANT_BOOL* Cancel);
			[id(24)] void OnDownloadUpdated(LONG ID, BSTR URL, BSTR OriginalUrl, BSTR MimeType, BSTR FullPath, BSTR SuggestedFileName, LONG TotalBytes, LONG ReceivedBytes, LONG PercentComplete, LONG CurrentSpeed, VARIANT_BOOL* Cancel);			
			[id(25)] void OnBeforeNavigate(LONG ID, LONG BrowserID, LONG FrameID, BSTR FrameName, VARIANT_BOOL IsRedirect, NAV_RESOURCE_TYPE ResourceType, NAV_TRANSITION_TYPE TransitionType, BSTR Method, BSTR ReferrerURL, BSTR CurrentURL, BSTR* NewURL, VARIANT_BOOL* Cancel);			
			[id(12)] void OnEvent(BSTR EventType, BSTR EventSelector, BSTR TargetSelector, BSTR TargetPath, BSTR EventData, VARIANT_BOOL Async, VARIANT_BOOL* PreventDefault, VARIANT_BOOL* CancelBubble);
	};

	//  Class information for CWebKitXCEF3Ctrl
	[
		uuid(DFF43867-EAC5-4170-96B0-265A91723BCA)
	]
	coclass WebKitXCEF3
	{
		[default] dispinterface _DWebKitXCEF3;
		[default, source] dispinterface _DWebKitXCEF3Events;
	};

	[
		uuid(9CC49284-7BCE-4BB1-9FE9-A8CFC1029CD2)		
	]
	coclass Settings
	{
		[default] interface ISettings;
	};
		
};

WebKitX SamplesWebKitX 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 Edition (no editing possible). You can embed WebKitX in your applications with just 3 lines of code!

History

On December 2014 mobileFX open sourced on GitHub WebKitX based on CEF1: Chromium Embedded Framework (CEF1) ActiveX Wrapper (Dec 2014). Since then we received tons of requests (and bounties) from Visual Basic 6 programmers for a CEF3 version of our ActiveX. Since CEF1 and CEF3 have completely different architectures, we decided to write the new ActiveX from scratch. At the same time we wanted CEF3 WebKitX to be suitable for commercial products and HTML5 Editors (such as Coconut2D) and designed several innovative features for it. 

On December 2017 we decided to finally implement the CEF3 version of WebKitX as an affordable commercial solution, with proper support. WebKitX for CEF3 has quite some unique innovations on it, such as the back-to-back COM-to-IPC bus implementation, care for multithreading and our own HTML5 editing and selection engine that we will keep evolving.

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.