JxBrowser Changelog

What's new in JxBrowser 7.38.1

Apr 12, 2024

We upgraded Chromium to a newer version, which introduces multiple security fixes that prevent a remote attacker who had compromised the GPU process from potentially perform a sandbox escape via specific UI gestures, potentially exploit heap corruption via a crafted HTML page, including:
CVE-2024-3157: Out of bounds write in Compositing
CVE-2024-3516: Heap buffer overflow in ANGLE
CVE-2024-3515: Use after free in Dawn
CVE-2024-3159: Out of bounds memory access in V8
Quality enhancements:
Fixed incorrect scaling when opening JavaFX BrowserView on non-primary display with a different scale factor in the off-screen rendering mode on Windows.
The Print Preview dialog is now placed properly after moving Java Swing window to full screen on macOS.
Fixed a freeze during Profile creation on Windows.
Improved stability during SSL certificate verification status retrieval.

New in JxBrowser 7.38.0 (Mar 18, 2024)

New in JxBrowser 7.37.2 (Feb 27, 2024)

New in JxBrowser 7.37.1 (Jan 22, 2024)

New in JxBrowser 7.37.0 (Dec 21, 2023)

New in JxBrowser 7.36.3 (Dec 1, 2023)

New in JxBrowser 7.36.2 (Nov 23, 2023)

New in JxBrowser 7.36.1 (Nov 17, 2023)

New in JxBrowser 7.36 (Oct 17, 2023)

New in JxBrowser 7.35.2 (Oct 6, 2023)

New in JxBrowser 7.35.1 (Sep 18, 2023)

New in JxBrowser 7.35 (Sep 2, 2023)

New in JxBrowser 7.34.1 (Aug 9, 2023)

New in JxBrowser 7.34 (Aug 4, 2023)

New in JxBrowser 7.33.2 (Jun 29, 2023)

New in JxBrowser 7.33.1 (Jun 20, 2023)

New in JxBrowser 7.33 (Jun 12, 2023)

New in JxBrowser 7.32 (May 5, 2023)

New in JxBrowser 7.31.1 (Apr 20, 2023)

New in JxBrowser 7.31 (Mar 20, 2023)

New in JxBrowser 7.30.3 (Feb 24, 2023)

New in JxBrowser 7.30.2 (Feb 6, 2023)

New in JxBrowser 7.30.1 (Feb 3, 2023)

New in JxBrowser 7.30 (Feb 1, 2023)

New in JxBrowser 7.29 (Dec 23, 2022)

New in JxBrowser 7.28.1 (Oct 4, 2022)

New in JxBrowser 7.27 (Aug 4, 2022)

New in JxBrowser 7.26 (Jun 16, 2022)

New in JxBrowser 7.25 (Jun 6, 2022)

New in JxBrowser 7.24.4 (Apr 21, 2022)

New in JxBrowser 7.24.3 (Apr 8, 2022)

New in JxBrowser 7.24.2 (Apr 5, 2022)

New in JxBrowser 7.24.1 (Mar 31, 2022)

New in JxBrowser 7.24 (Mar 29, 2022)

New in JxBrowser 7.23 (Mar 9, 2022)

New in JxBrowser 7.22 (Feb 17, 2022)

New in JxBrowser 7.21.2 (Dec 31, 2021)

New in JxBrowser 7.21.1 (Dec 23, 2021)

New in JxBrowser 7.21 (Dec 3, 2021)

New in JxBrowser 7.20 (Nov 5, 2021)

Chromium 94:
Chromium has been upgraded to version 94.0.4606.113.
The Chrome/Chromium minimum system requirements have been changed in version 94, so JxBrowser system requirements have been updated too.
In March 2021, Google announced that Chrome/Chromium is planning to move to releasing a new milestone every 4 weeks, starting with Chrome/Chromium 94 in Q3 of 2021. Additionally, they added a new Extended Stable option, with milestone updates every 8 weeks. Security updates on Extended Stable will be released every two weeks to fix important issues, but those updates won’t contain new features or all security fixes that the 4 week option will receive.
This Chromium build is part of the Extended Stable update. It includes all security fixes and new features introduced in Chromium 94.
As usually, we recommend that you use the latest JxBrowser versions with the latest Chromium builds.
Windows 11:
Windows 11 has been included to the list of supported platforms and, now, officially supported.
JavaScript:
The JavaScript Java API has been extended with new types:
JsArray
JsSet
JsMap
JsArrayBuffer
A JavaScript object of one of these types can be passed between Java and JavaScript as a method argument or a return value. The object lifetime is bound to the lifetime of the frame this object belongs to. When the owner frame is unloaded, all the JavaScript objects are automatically disposed. An attempt to access a disposed JavaScript object will result in IllegalStateException.
Converting to Java Collection:
Each type allows getting a corresponding unmodifiable Java collection containing the converted JavaScript collection elements:
Automatic Type Conversion:
When you add or insert an element to JavaScript collection, it will be automatically converted to a corresponding JavaScript type according to the following type mapping rules:
If you pass a non-primitive Java object to JavaScript, it will be converted into a Proxy Object. Method and property calls to this object will be delegated to the Java object. For security reasons, JavaScript can access only those methods and fields of the injected Java object that are explicitly marked as accessible either using the @JsAccessible annotation or via the JsAccessibleTypes class.
Java collections that are not made accessible to JavaScript using the @JsAccessible annotation or via the JsAccessibleTypes class are converted to JavaScript collections. The content of the converted collection is a deep copy of the Java collection. Modifications of the converted collection in JavaScript do not affect the collection in Java.
Java collections that are made accessible to JavaScript using the @JsAccessible annotation or via the JsAccessibleTypes class are wrapped into a JavaScript proxy object. Such proxy objects can be used to modify the collection in Java.
Binary Data:
You can transfer binary data between JavaScript and Java and vice versa, using JavaScript ArrayBuffer and its JsArrayBuffer Java wrapper. For example:
@JsAccessible:
We extended the list of supported cases where you can use this annotation and added support of interfaces.
Now you can make accessible to JavaScript:
A top-level class or an interface
A nested static class or an interface
A non-static method of a class or an interface
A non-static field of a class
You can find more information on how to use this annotation in Annotation Rules.
Screen Sharing:
The library has been extended with the new API that allows you to access Chromium Screen Sharing functionality. Now, if a web page wants to share your screen, you will see the standard Chromium dialog as shown below:
WebRTC Screen Sharing Dialog:
In this dialog you can choose whether you would like to share the entire screen, a specific window, or a web page loaded in other Browser instances.
We also extended the API to let you programmatically handle the screen sharing requests from a web page.
Web Form Autofill:
In this version the web form autofill functionality has been implemented. By default, it’s enabled. You can disable it using the Profile Preferences API:
Password Store:
Chromium has a built-in functionality that allows remembering the entered credentials when the user submits a new form containing username and password. The library will ask you if you’d like to save the credentials.
If you save them, the next time you load the form, the library will suggest autofill it.
Web Form Autofill Passwords:
To access and manage all saved passwords, use PasswordStore you can access using:
PasswordStore passwordStore = profile.passwordStore();
Default Font Size:
Modify the default font size of the web pages loaded in Browser using the new setting:
Browser.settings().defaultFontSize(FontSizeInPixels.of(12));
Printing:
The Printing API has been extended with new settings and property.
Header and Footer:
Now you can set a custom HTML in the header and footer of the printed document when printing programmatically without displaying the Print Preview dialog. For example:
Scaling:
You can change scaling of the printed document. In case of custom scaling, scale amount must be a number between 10 and 200.
Printer Name:
Apart from the printer device name, you can get the name of the printer as understood by operating system:
Improvements:
The time between initiating printing and the PrintHtmlCallback and PrintPdfCallback callbacks invocation has been reduced. The root cause of this performance issues was that the library collects the available printers and their capabilities before invoking the callbacks. In this version, the library collects only the available printers, without their capabilities, and requests the capabilities for the concrete printer on demand.
Now, it’s possible to enable WebRTC logging using the --enable-logging and --vmodule=*/webrtc/*=1 Chromium switches.
Fixed issues:
Fix the issue when JavaScript performance goes down after BrowserView manipulations. To solve the issue we disabled the occlusion management feature on Windows in both rendering modes. Chromium has the logic to track down when its window gets occluded (becomes hidden by another window in the system) and performs corresponding notifications into a render process with subsequent CPU usage optimization. This optimization slows down JavaScript execution.
Fix crash in the Main Chromium process on Linux after attempt to delete a Profile, whose Browser was just focused.
Fix crash in the Main Chromium process on Windows when closing Browser during handling the mouse and keyboard events.
Fix crash when closing a JavaScript dialog after the Browser instance, with the web page initiated the dialog, has been closed on Linux.
Fix crash when you drag and drop on a web page after dragging and dropping an item from the Java component on Linux in the hardware accelerated rendering mode.
Fix the issue when PrintCompleted never comes when programmatically print a web page with the PageRange setting.
Fix the issue when BrowserView is blurred on a secondary HiDPI monitor with scaling 150% after hiding and showing the view on Windows.

New in JxBrowser 7.19 (Sep 9, 2021)

Chromium 92:
Chromium has been upgraded to version 92.0.4515.159.
This Chromium version includes nine important security fixes, so we recommend that you upgrade to this version.
Java 17:
Java Development Kit (JDK) is set to launch in September 2021. It will be a long-term support (LTS) version, with extended support from Oracle. We tested the library with Java 17 on all supported platforms and didn’t find any issues. So, you can use this version with Java 17 already. As soon as Java 17 is officially released, we will include it into the list of supported Java versions.
SWT DnD:
Now you can drag and drop text, links, images, files in the SWT BrowserView component in the off-screen rendering mode on Windows, Linux, and macOS. Drag and drop functionality is enabled by default.
Load Progress Events:
The Navigation API has been extended with the LoadProgressChanged event that allows you to get notifications about load progress:
navigation.on(LoadProgressChanged.class, event -> {
// The load progress between 0 and 1.
double progress = event.progress();
});
Upload Data Bytes:
The library now allows retrieving bytes from upload data. This enhancement introduces several API changes:
The UploadData.bytes() method has been added.
The BeforeSendUploadDataCallback.Params.httpHeaders() method has been added to be able to get the boundary to parse multipart/form-data from raw bytes.
The BytesData class has been renamed to ByteData.
Custom DnD Data:
In the off-screen rendering mode DnD supports several data flavors: url, text, html. At the same time, JavaScript might put some custom data into transferable via DataTransfer.setData(). In the previous versions the library just ignores this custom data. Now, the library supports the DnD custom data on all supported platforms.
Fixed issues:
JVM crash on an attempt to find the native window handle in JavaFX 16 on macOS.
Deadlock on processing nested calls in Chromium render process.
Crash when canceling printing during collecting printer capabilities.
The IllegalStateException error when calling Frame.children().
The dependency checker error on Linux due to the wrong library name. The libawt_helper.so library has been renamed to libawt_toolkit.so.

New in JxBrowser 7.18 (Aug 14, 2021)

New in JxBrowser 7.17 (Jul 20, 2021)

Chromium 91:
Chromium has been updated to version 91.0.4472.114.
This Chromium version includes several important security fixes, so we recommend that you upgrade to this version.
Some Chromium features have been removed or changed. Check out the migration guide to see what JxBrowser API has been removed and what alternatives you should use instead.
Profiles:
In this version we extended the API with functionality that allows managing Chromium profiles. Now, the architecture has the following structure:
JxBrowser Architecture:
Each Engine has a default Profile you can access via:
Profile defaultProfile = engine.profiles().defaultProfile();
The following services now belong to Profile, so you can manage cookies, downloads, permissions, plugins, etc. independently for every profile:
ZoomLevels
Plugins
Proxy
Network
SpellChecker
CookieStore
HttpCache
HttpAuthCache
Downloads
Permissions
To create a new regular or incognito profile use the following API:
Profiles profiles = engine.profiles();
Profile myProfile = profiles.newProfile("MyProfile");
Profile myIncognitoProfile = profiles.newIncognitoProfile("MyIncognitoProfile");
Every Browser instance has a profile. To create a Browser instance for specific profile use the following way:
Browser browser = profiles.defaultProfile().newBrowser();
...
Profile myProfile = profiles.newProfile("MyProfile");
Browser browser = myProfile.newBrowser();
For the backward-compatibility we didn’t change the Engine interface. It just delegates its calls to the default profile. For example:
Browser browser = engine.newBrowser();
// is equivalent of
Browser browser = engine.profiles().defaultProfile().newBrowser();
and
CookieStore cookieStore = engine.cookieStore();
// is equivalent of
CookieStore cookieStore = engine.profiles().defaultProfile().cookieStore();
If you configure Engine with the user data directory, then all created profiles will be restored after application restart unless you delete a profile via Profiles.delete(Profile).
Please note that the default profile cannot be deleted.
JS Promises:
Our automatic type conversion from JavaScript to Java types and vice versa has been extended with support of JavaScript Promise. Now, you can work with JavaScript Promises through the brand new JsPromise type.
Network Connection State:
Chromium internally tracks the Internet connection status. When the Internet connection is dropped and then restored, Chromium detects this and programmatically reloads the currently loaded web page. In this version we extend the API with this functionality. Now you can get notifications when the network connection state is changed. For example:
Enhancements:
The NavigationFinished event has been extended with isFragmentNavigation() that indicates whether navigation has been performed to a fragment within the same document.
Fixed issues:
The native Chromium window is detached when JavaFX BrowserView is embedded into TabPane and Stage is restored after minimize on Linux in the hardware accelerated rendering mode.
Chromium crash when closing Browser after using the set Desktop Affinity API.
Browser steals the input focus when Java window is displayed on Linux in the hardware accelerated rendering mode.
An attempt to execute UI-related methods in the popup browser opened by Frame.viewSource() causes a native crash on Windows.
The missing drop data from the D&D inside a web page displayed in Swing BrowserView on macOS.
Support custom text representations in Swing D&D functionality in the off-screen rendering mode.

New in JxBrowser 7.16 (Jun 9, 2021)

View Page Source:
Now you can view source of the loaded web page or frame like in Google Chrome: browser.mainFrame().ifPresent(Frame::viewSource);
The code above tells Chromium to create and open a popup window with the HTML source of the main frame.
Default Background Color:
When Chromium does not know the background color of a web page, or the color has not been specified at all, it uses the white color. In this version we extended the API with new functionality that allows you to configure the default background color that Chromium should use instead of the default white color in such cases.
Enhancements:
Invoking the Frame.print() method doesn’t cause the requests to the external Google Cloud Print service when the Chromium traffic is disabled.
Fixed issues:
Keyboard input does not work after JavaScript Alert dialog has been closed.
Chromium crash during media device selection.
Chromium crash when opening a drop-down popup in the Print Preview dialog on macOS.
Chromium crash when moving a window with BrowserView from one display to another.
Unable to click UI controls in the Print Preview dialog if it’s displayed on a secondary display when the primary display has scale factor more than 100% on Windows.
The drop action might be ignored in the off-screen rendering mode.
The dragged HTML from another application to BrowserView in the off-screen rendering mode is not recognized as HTML.
The dragged URL from another application to BrowserView in the off-screen rendering mode is not recognized as URL on Linux.
The com.google.protobuf.InvalidProtocolBufferException: Protocol message had invalid UTF-8 error when the library processes the ReceiveHeaders params that contain status line with the non-UTF-8 characters.
Making text bigger on Windows 10 breaks rendering in the off-screen rendering mode and causes wrong BrowserView bounds in the hardware accelerated rendering mode. Now, the library just ignores this setting and take into account only the “Make everything bigger” setting.
The SWT BrowserView control doesn’t repaint web page when it’s embedded into a scrollable area and user scrolls its content in the off-screen rendering mode on Windows.
Broken rendering on the web pages that displays semi-transparent HTML elements on macOS. Instead of the elements the black rectangles are displayed.

New in JxBrowser 7.15 (May 1, 2021)

New in JxBrowser 7.14 (Apr 1, 2021)

What’s New:
Chromium 89:
Chromium has been updated to version 89.0.4389.90
This Chromium version includes several important security fixes, so we recommend that you upgrade your JxBrowser to v7.14.
Flash EOL
Chromium does not support Flash anymore. All the Flash-related functionality is removed from its source code. In this version we remove the following Flash-related API too:
EngineOptions.ppapiFlashPath()
EngineOptions.ppapiFlashVersion()
EngineOptions.Builder.ppapiFlashPath(Path ppapiFlashPath)
EngineOptions.Builder.ppapiFlashVersion(String ppapiFlashVersion)
Improvements:
Rectangular shape of BrowserView is now enforced on Linux in both rendering modes. In the previous versions BrowserView had rounded corners.
The number of Chromium processes when instantiating an Engine instance is reduced. In the previous version, Chromium launched 7 processes: Main, GPU, 2x Utility, 3x Renderer. Now only 4 processes are launched: Main, GPU, Utility, Renderer.
It got possible to create HAR files in DevTools.
Chromium traffic to the local network IPs has been disabled. We figured out that even when Chromium traffic is disabled, Chromium still sends request to URLs such as URLs http://10.0.0.17:8060 or http://192.168.1.188. These URLs are related to the Media Router feature used by Chromium to discover media devices it can cast to. Since the library doesn’t support casting to the media devices, we disabled this feature to suppress such URL requests.
Always return focus to JavaFX when closing BrowserView.
Fixed issues:
The InvalidProtocolBufferException error when BeforeSendUploadDataCallback.Params.uploadData() has non-UTF-8 text. Now, if the upload data has non-UTF-8 text, the data is treated as com.teamdev.jxbrowser.net.BytesData.
Wrong scaling after hiding and showing BrowserView on a secondary display with scale factor different than the primary display on Windows.
Flickering when adding/removing BrowserView from a JavaFX SplitPane in the hardware accelerated rendering mode on Windows.
Popup window reducing its size when resized.
The web page not loaded because of the SSL handshake failure when navigating to a certain HTTPS URL.
Broken jQuery file drag and drop in the off-screen rendering mode.
The FocusGained event not fired on macOS.
Chromium binaries verification failing with permission error on Linux.
The default spell checker context menu not being closed when clicking outside it on Windows.
The read/write permissions for JavaScript Clipboard API not being granted.
Broken Chromium Win32 binaries verification.
Crash on web pages with text input during spell checker initialization.

New in JxBrowser 7.13 (Mar 2, 2021)

NEW:
Chromium 88:
Chromium has been updated to version 88.0.4324.182.
In this Chromium build, some of its features wrapped with the JxBrowser have been removed or changed, so this version of our library introduces several breaking changes in the public API.
Check out the migration guide for this version to see what API has been removed and what alternatives you should use instead.
Printing API:
Now you can print a web page or PDF document programmatically without displaying the Print Preview dialog.
With the new Printing API you can:
select a printer device;
provide the required print settings such as paper size, orientation, page ranges, etc.;
get notifications when printing is completed;
cancel printing;
save the currently loaded web page to a PDF document and more.
Custom Schemes:
The way of intercepting the requests is improved. To intercept URL requests with the custom jxb scheme, add the corresponding scheme and associate it with an intercept callback
Now, if you load jxb://anyhost/anypage.html, the URL requests will be intercepted, and the associated callback will be invoked. You will get the following output:
Custom Scheme:
External Apps:
Some applications installed in the operating system might be associated with a specific URI scheme. When user navigates to a URL with the scheme associated with the installed application, Chromium displays a dialog where the user can decide whether the link should be opened in the associated external application or not.
With this update, we introduced the callback that you can use to intercept such cases and display your own dialog to the end users or programmatically open the external application without prompting the user. For example:
browser.set(OpenExternalAppCallback.class, (params, tell) -> tell.open());
When you create a Swing, JavaFX, and SWT BrowserView instance, this callback is registered automatically, if it is not already registered, and displays a corresponding dialog
Open External App Dialog:
Improvements:
Allow resizing Browser to 1x1. In the previous versions the minimum size was defined by the operating system.
Enable the multiple files download. Now, when you download multiple files, the StartDownloadCallback callback will be invoked for each file.
Handle the case when some system calls are interrupted with the EINTR signal on macOS and Linux. Which could lead to a native crash in the Chromium engine.
Allow configuring the render process unresponsive timeout via the --hung-render-delay-seconds=45 Chromium switch.
Allow empty username and password in AuthenticateCallback.
Fixed issues:
The (SWT:12502): GLib-GObject-CRITICAL **: 14:58:41.997: g_object_set_data: assertion 'G_IS_OBJECT (object)' failed error when displaying a context menu in SWT BrowserView in the hardware accelerated rendering mode on Linux.
Incorrect key codes for numpad when receiving the keyboard events in the hardware accelerated rendering mode.
The IllegalStateException error when closing the Swing BrowserView popups in the off-screen rendering mode.
The BrowserView bounds not being updated when the component is embedded into a Swing container with the absolute layout and they have changed programmatically in the off-screen rendering mode.
Crash in the Main Chromium process when loading IFRAME with src="data:image/gif;base64,R0lGODlhE....
Crash in the Main Chromium process when multiple “Select Client SSL Certificate” dialogs are displayed, and a user selects a custom SSL certificate in one of them.
Angular apps not “seeing” some keyboard events in the off-screen rendering mode.
The Frame.children() method returning all nested children when it must return only immediate children.
The StartDownloadCallback.Action.cancel() action not cancelling download.

New in JxBrowser 7.12.1 (Dec 15, 2020)

Improvements:
Skip the CFProcessPath environment variable on macOS when launching the Main Chromium process. If we launch the process with this variable, Chromium won’t be able to find its internal resources and fail to start. The CFProcessPath environment variable is used on macOS to enable the possibility to drag items onto the application’s dock icon for processing.
Hide the Advanced button on the error web page that is shown when you load an HTTPS web page with invalid SSL certificate. The only way to load a web page with invalid SSL certificate is to use the CertificateErrorCallback as shown below:
browser.set(CertificateErrorCallback.class, (params, tell) -> tell.allow());
The jxbrowser.force.dpi.awareness system property has been added. The presence of this property tells the library that the DPI awareness mode of the current Java process should be programmatically set to System before launching the Main Chromium process.
This property addresses the HiDPI issue in Java 8u211+. When creating an Engine instance before UI toolkit is initialized, the Java and Chromium processes end up with the different DPI awareness modes. This leads to the rendering issues in the HiDPI environments. It is because starting from 8u211, Java does not enforce any DPI awareness mode to the applications via manifest like before. Since 8u211, Java starts unaware and lets the application configure the DPI awareness mode programmatically during UI toolkit initialization.
When the library runs the Chromium process, it does not know whether a UI toolkit has been initialized and configured the DPI awareness mode. It is important to know this in order to synchronize the modes between Java and Chromium processes. To workaround the issue we decided to set the Java DPI awareness mode programmatically if this property is set. In this case we do not care whether a UI toolkit has been initialized or not. We just set the mode and launch the Chromium process. In this case the DPI awareness mode of Java and Chromium will be the same.
Allow access to LocalStorage from JavaScript if the web page was loaded from a JAR archive.
During Engine initialization Kaspersky shows a security warning that “Chromium is attempting to get access to webcam”. We updated the initialization flow, so that the webcam functionality is initialized only when web page requests access to it. It allows suppressing the warning dialog during Engine startup.
Fixed issues:
Chromium crash when loading about:blank after http://localhost/any.xml.
Chromium crash when loading a data URI to a non-main frame.
Chromium crash when accessing content document of an IFRAME if loading content of the IFRAME was canceled.
JVM crash when opening RPC connection on macOS and Linux.
Dragging/selecting items inside a web page might lead to a situation when browser becomes unresponsive or JVM crash in the off-screen rendering mode on Windows and Linux.
When dispatching the MouseMoved events to the Chromium in the off-screen rendering mode, no keyboard modifiers are passed. As a result, no keyboard modifiers are received on the JavaScript side.
Thread deadlock when accessing the main frame of the currently loaded web page from the main SWT thread in the hardware accelerated rendering mode on Windows.
Thread deadlock when accessing the URL of the currently loaded web page from the main SWT thread in the hardware accelerated rendering mode on Windows when displaying popups.
Thread deadlock when accessing cookies from the main JavaFX thread in the hardware accelerated rendering mode on Windows after closing javafx.scene.control.TextInputDialog.
Thread deadlock when frequently showing/hiding JavaFX BrowserView in the hardware accelerated rendering mode on Windows.
Invalid key codes in JavaScript for the NumPad keys in the off-screen rendering mode.
Invalid key codes in JavaScript for the Enter, Tab, Backspace keys when dispatching the KeyTyped event in the hardware accelerated rendering mode on Swing.
Incorrect KeyboardEvent.location is passed for the NumPad, Left, and Right keys in the off-screen rendering mode.
Popups size and location are calculated improperly when non-default DPI is set in the operating system.
Cannot access content document of an IFRAME which loads a web page from another domain.
Memory leak in the Chromium Render process when working with the DOM and JavaScript objects in the different web pages using JxBrowser DOM and JavaScript API.
Scrolling doesn’t work after SWT BrowserView was once hidden in the off-screen rendering mode.
Chromium window gets destroyed after JavaFX Stage is hidden with the embedded BrowserView in the hardware accelerated rendering mode on Linux.
JavaFX BrowserView dispatches Enter twice in the off-screen rendering mode.
Drag and Drop between JavaFX BrowserView and other JavaFX controls doesn’t work in the off-screen rendering mode on Linux for JavaFX older than 14th.
Drag and Drop on the web pages that use the custom drag data doesn’t work properly in the off-screen rendering mode.
In JavaFX off-screen rendering mode, within JxBrowser when we try to drag the text into the text area for the first time, we get it, but if we try to do the same again, the text will not be dragged. The same thing with links that can stop being dragged into the text area, after one successful drag and drop.
Black JavaFX BrowserView after hiding then showing in the off-screen rendering mode.
HTML slider doesn’t work in SWT BrowserView in the off-screen rendering mode.
Incorrect size of the popup that is displayed after suppressing the previous popup.

New in JxBrowser 7.12 (Nov 10, 2020)

Improvements:
Now the library passes the JS tests that check “MovementX and MovementY vary in mouse events” in the off-screen rendering mode.
Since this version, the Frame.isMain() method does not send a request to the Chromium engine to find out whether this frame is a main (top-level) frame in the browser or not. Now, this information is provided when creating a Frame and cached for further calls.
Running the Chromium executable shipped with the JxBrowser Chromium binaries is not allowed now. The Chromium binaries used by JxBrowser are supposed to be used only by JxBrowser and users should not be able to run it directly and use it as a regular web browser application.
Embedding JavaFX BrowserView into the containers that inherits JFXPanel is now allowed.
The TextFinder Javadoc has been extended with additional details on how the text search works, how it highlights the matches, how the first match is detected, etc.
By default, Chromium creates the debug.log file in the directory where the binaries are located. In some environments access to this directory might be forbidden and the operating system might report such attempts. Since this version, Chromium will not be creating the debug.log file anymore and the corresponding log messages will be redirected to JxBrowser logging.
Now, the Chromium build used in the library is built using the is_official_build=true flag. The official Chromium build disables the experimental Study Configurations that are disabled in the official Google Chrome builds. One of such experimental functionalities that was enabled in the previous versions of JxBrowser, is Page Freezing that might freeze the web page and stop JavaScript execution. So, the Chromium engine used by the library becomes closer to the official Chromium builds in terms of the enabled/disabled internal functionality.
Functionality that triggers Windows Audit Failures is disabled. The issue was caused by Chromium calling the LogonUser() function from Windows API, and passing an empty password to it. We resolved the issue by disabling functionality that tries to log on using an empty password. This change does not affect any other Chromium functionality.
Fixed issues:
The “Aw, snap” page not displayed when Chromium render process is crashed.
Broken rendering introduced in 7.9 in JavaFX in the off-screen rendering mode on Windows.
Web content not displayed after hiding and showing JFrame with the embedded BrowserView in the hardware accelerated rendering mode on Linux.
The HTML5 Drag and Drop events with empty data flavor ignored in the off-screen rendering mode, which resulted in some HTML5 DnD events not working at all.
The NullPointerException error when dragging a file from the file system to the Swing BrowserView instance in the off-screen rendering mode.
The NullPointerException error when displaying JavaFX Scene with the embedded BrowserView instance after the primary Stage is shown in the off-screen rendering mode.
CookieStore not saving the cookies with the unspecified SameSite attribute.
ShowContextMenuCallback not called when right-clicking inside PDF Viewer.
The off-screen rendering not working on Linux with NVidia GeForce 1650 and the 430.64 driver version.
The JavaScript-Java Bridge functionality not being able to call a Java method marked with the @JsAccessible annotation if there are other methods with the same name.
The spell checker dictionaries not being configured when the Engine instance is running in the Incognito mode.
Broken rendering in the Print Preview dialog in the hardware accelerated rendering mode in SWT on macOS.
The Print Preview dialog not displayed in the off-screen rendering mode in SWT on macOS.
The default Swing BrowserView context menu being not visible when right-clicking Flash on a web page in the hardware accelerated rendering mode on Windows and Linux.
Browser unable to be resized to a size smaller than 300px on macOS.
The DOM event listener for EventType.DOUBLE_CLICK never being invoked.
The EnterMouseCallback and ExitMouseCallback not being called in the off-screen rendering mode. In the hardware accelerated rendering mode on Windows and Linux the EnterMouseCallback could not be invoked because it was ignored by the Chromium engine.
The SWT BrowserView component being not visible in Eclipse’s Part on tab switch in the off-screen rendering mode.
Wrong default save file name when printing the currently loaded web page to PDF in SWT.
Spell checker initialization failure when typing some text in an input field on the loaded web page with disabled Chromium traffic.
The custom CSS cursors blurred on Windows in the off-screen rendering mode.
Black flickering when adding/removing JavaFX BrowserView into SplitPane in the hardware accelerated rendering mode on Windows.
Flickering with a random black rectangle when showing/hiding BrowserView in the off-screen rendering mode on Windows.
The methods marked with the @JsAccessible annotation of a Java object injected into JavaScript being called one more time on closing Browser.
The IndexOutOfBoundsException error when closing the Swing BrowserView popup instance via the window.close() JavaScript function.
The ShowNetErrorPageCallback callback not being called when loading an HTTPS web page with an invalid SSL certificate.
Not being able to set focus to an HTML input field located inside an IFRAME with the different domain in the off-screen rendering mode.
Support of Firebase Cloud Messaging is restored.
Widevine functionality on macOS and Windows is re-introduced after v7.8.
The MouseEvent.movementX and MouseEvent.movementY attributes should be different for the different mouse move events in the off-screen rendering mode.
JVM crashes due to multiple errors in the JNI related to mach_port functionality on macOS.

New in JxBrowser 7.11 (Oct 5, 2020)

What’s New:
Amazon Corretto and AdobtOpenJDK
Use JxBrowser with Amazon Corretto and AdoptOpenJDK 8 and 11 on Windows, macOS, and Linux with all supported UI toolkits such as Swing, JavaFX, and SWT.
Read more about all supported JDKs and platforms.
Accessing Java fields from JavaScript
Access the public fields of a Java object injected into JavaScript through the JavaScript-Java Bridge API.
The JavaScript-Java Bridge API allows injecting Java objects into JavaScript and calling their public methods annotated with @JsAccessible. Now, you can access the public fields as well by making them accessible from JavaScript via the @JsAccessible annotation. For example:
public class JavaObject {
@JsAccessible
public String accessibleField;
...
JsObject window = frame.executeJavaScript("window");
window.putProperty("java", new JavaObject());
Now you can access and modify the value of the accessible field from JavaScript:
window.java.accessibleField = "My value";
Improvements:
The BrowserView re-parenting is properly handled in SWT in the hardware accelerated rendering mode now.
The library detects when parent Composite of BrowserView has been shown/hidden in Eclipse RCP in the hardware accelerated rendering mode.
All references to the Swing classes in the JavaFX BrowserView implementation have been removed.
The Hunspell dictionaries on Windows and Linux will not be downloaded if spell checking is disabled.
Fixed issues:
BrowserView in Eclipse tabs overlapping other tabs in the hardware accelerated rendering mode on Windows.
The RequestCompleted and RequestDestroyed events fired when URL request has not started because it was canceled in LoadResourceCallback.
Blurred custom cursors on Windows in the off-screen rendering mode.
The public methods marked with @JsAccessible called twice when closing Browser.
The SWT Print Preview dialog not displayed in the off-screen rendering mode on macOS.
The IndexOutOfBoundsException error when closing popup Browser through the window.close() JavaScript function.
The IllegalStateException error in BrowserView during closing its Browser instance in the hardware accelerated rendering mode.
JavaFX BrowserView overlapping content when it’s embedded into a TabPane in the hardware accelerated rendering mode on macOS.
The random black rectangles flickering inside BrowserView when it has been shown on Windows.
The random black and white rectangles flickering inside BrowserView instead of a web page on Windows in off-screen mode.
Flickering on every repaint when Swing BrowserView is embedded into an AWT container on Windows in off-screen mode.
Unexpected Chromium termination with exit code 139 on Linux when closing Engine.
Crash when typing text in an input field on a web page when Chromium traffic is disabled on Linux and Windows.
Crash when loading about:blank right after loading an invalid URL.
Crash when closing popup in hardware accelerated on Windows and Linux.
BrowserView in the off-screen rendering mode not handling focus properly if a web page contains IFRAME that displays a web page with an input field that is hosted on another domain and the focus was requested during the page loading. In this case, when you clicked on the input field you could type into it, however, the cursor did not appear.
Wrong DisplayId when closing minimized SWT BrowserView inside Eclipse RCP on Windows in the hardware accelerated rendering mode.
Wrong SWT BrowserView location inside Shell on Linux in the hardware accelerated rendering mode.
Deadlock when closing Engine from BrowserClosed.
The SetWindowDisplayAffinity function not able to be applied to the Java window with embedded BrowserView in the hardware accelerated rendering mode on Windows.
The keyboard focus staying inside Swing BrowserView after Tab or Shift+Tab in hardware accelerated mode.
Freeze on System.exit(0).
Failure to print a PDF document loaded in IFRAME.

New in JxBrowser 7.10 (Aug 14, 2020)

New in JxBrowser 7.9 (Jul 16, 2020)

The OpenPopupCallback never called and, as a result, the popup never displayed when clicking a link with the rel='noopener noreferrer' attribute.
The java.lang.NullPointerException error when JavaFX BrowserView is embedded into the javafx.scene.control.Alert dialog.
The Swing Drag & Drop events blocked if a BrowserView is hidden before data drop.
The request permission dialog displayed when downloading multiple files.
The Chromium GPU crash when docking/undocking Swing BrowserView in NetBeans 11 window on Linux in the hardware accelerated rendering mode.
Swing BrowserView not resized properly when embedded into a JTabbedPane and the tabbed pane is being resized.
Closing Java window with at least one embedded BrowserView leading to unexpected closing of all Browser instances in the off-screen rendering mode on Windows.
Freeze when calling Browser.bitmap() in the off-screen rendering mode on Linux.
The BrowserView component displaying the window caption with the minimize, maximize, and close buttons for a short period of time in the off-screen rendering mode with disabled GPU and enabled transparent backgrounds on Windows.
The web form not being submitted if the file was set using the InputElement.file(String...) method.
The DOM change event not triggered when setting a file via the InputElement.file(String...) method.
The FrameLoadFailed event with the BLOCKED_BY_RESPONSE error is not fired when navigation inside an IFRAME fails because of the X-Frame-Options: sameorigin HTTP header.
The first loaded web page not rendered on Windows 7 and Windows Server 2008 R2 in the off-screen rendering mode.
The first loaded web page not rendered in JavaFX BrowserView if it becomes visible after the web page has been completely loaded in the corresponding Browser instance in the off-screen rendering mode.
The java.lang.IllegalStateException error when unfocusing SWT BrowserView when its corresponding Browser instance is already closed.
Thread deadlock when displaying multiple popups in the hardware accelerated rendering mode on Windows.
UrlRequest not having an ID when it is completed and destroyed.
The TitleChanged event not fired when navigating back/forward in the navigation history list.
The single-pixel white line in the fullscreen mode on Linux and the hardware accelerated rendering mode.
Angular on a web page not receiving the required DOM events when pressing Enter on a text field in the off-screen rendering mode.
Broken JavaScript animation because the library does not flush HTML canvas in the off-screen rendering mode with enabled transparent background on Windows.
Touchpad click causing Engine to crash on macOS when attached to a remote debugging URL.
Tooltips not displayed in the hardware accelerated rendering mode on Windows.
The IllegalStateException error when disposing SWT BrowserView asynchronously.
The IllegalStateException error when pressing Cmd+Q on macOS when mouse pointer is over JavaFX BrowserView.
Thread deadlock when closing Browser during disposal of another SWT component.
The Command key not being passed to a web page on macOS with JavaFX BrowserView.

New in JxBrowser 7.8 (May 29, 2020)

New in JxBrowser 7.7.1 (May 25, 2020)

New in JxBrowser 7.7 (May 18, 2020)

What’s New:
SWT:
The library now provides the pure SWT com.teamdev.jxbrowser.view.swt.BrowserView control that can be embedded into the SWT/Eclipse RCP applications.
Eclipse RCP:
The SWT toolkit is often used in Eclipse RCP applications, so we prepared a short tutorial describing how to use the JxBrowser SWT BrowserView in an Eclipse RCP application.
JsFunction:
The JsFunction class has been restored in the JavaScript-Java Bridge API. Now you can work with the JavaScript functions directly from the Java code and pass the reference to a function from JavaScript to Java and vice versa.
Improvements:
The web pages are now being loaded two times faster, than in the previous versions due to the improvements in the loading time and the memory usage in the Chromium processes.
JxBrowser now supports Firebase Cloud Messaging.
The WebAssembly support is added.
With this version you can render the HTML <datalist> tag on the web pages.
The web form autofill functionality is now disabled by default.
You can now drag and drop files, images, text to and from the Swing/JavaFX BrowserView component on Linux, since the Drag and Drop functionality limitations in both rendering modes have been removed.
Since JxBrowser only supports the 64-bit version of Linux, it now throws an exception, upon an attempt to be run on Linux 32-bit. This is done by the new Environment.checkEnvironment() method responsible for detecting this unsupported environment.
Fixed issues:
The Swing BrowserView component not being visible when embedded into javax.swing.JApplet when the hardware accelerated rendering mode is enabled.
The internal test resources excluded from the JAR files.
Setting focus to Swing BrowserView via mouse click not clearing the focus from the currently focused Swing component on Windows.
The IllegalArgumentException error when displaying Swing BrowserView in the hardware accelerated rendering mode on Windows.
Double content rendering when Swing BrowserView is embedded into JScrollPane in the off-screen rendering mode on Windows.
Freeze on closing Browser during active repainting on the loaded web page in the off-screen rendering mode.
Swing application not receiving focus after clicking the JavaFX BrowserView embedded into JFXPanel in the hardware accelerated rendering mode on Windows.
Google reCAPTCHA not receiving focus via the Tab key.
The inability to type anything in the text fields located inside an IFRAME on a web page in the off-screen rendering mode.
Closing the window where the BrowserView component is embedded leading to closing all Browser instances in the off-screen rendering mode on Windows.
Freeze on closing Engine in the off-screen rendering mode on Windows and Linux because of timings.
Freeze on closing Engine after unsubscribing from getting the BrowserClosed events on Windows and Linux.
Chromium crash when loading the chrome://settings web page. This web page is disabled now.
The ClassCastException error when the Swing BrowserView component is embedded into JDialog and file download has been initiated.
A single-pixel white vertical line in the fullscreen mode on Linux in the hardware accelerated rendering mode.
Chromium log files being created in the directory with the Chromium binaries on macOS when the engine has crashed or unexpectedly terminated.
The white angles inside the BrowserView component on Ubuntu in the hardware accelerated rendering mode.

New in JxBrowser 7.0 (May 30, 2019)

We are excited to introduce you JxBrowser 7. This major version brings a lot of improvements and new features to the public API of the library.
The API has been extended with new classes, interfaces, methods, events and callbacks. We have also redesigned some of its parts to make it impossible to use the library in a wrong way.
The new version requires JDK 1.8 or higher. It allows us to bring the Java 8 features such as Optional, Lambda Expressions, Stream API, static methods in Interfaces, etc. to the public API and to the internal implementation.
The architecture of the library has been improved as well. Now you can run and control the life cycle of multiple Chromium instances in a single Java application. Each Chromium instance can be configured with its own user data directory, remote debugging port, language, etc. This change allows you to create and use two or more absolutely independent Browser instances simultaneously.
Architecture:
The new architecture has a new structure. With this update we introduced two new objects: Engine and Frame. The Engine provides the access to the core Chromium engine functionality. For each Engine instance a separate Chromium Main process is used.Each web page loaded in a Browser has a main Frame. The Frame itself may have child frames. You can use Frame to access and work with DOM and JavaScript.
Print Preview:
Now when you or JavaScript prints a web page, a standard Print Preview dialog can be displayed.
JavaScript & DOM:
Automatic Type Conversion:
JavaScript and Java work with different primitive types. JxBrowser 7.0 implements automatic type conversion from JavaScript to Java types and vice versa.
DOM Wrappers:
With automatic type conversion you can now access JavaScript DOM objects and work with them through JxBrowser DOM API.
Localization:
You can configure Engine with one of the supported languages
Not only the error pages support localization. The message dialogs support localization as well
Network:
With JxBrowser 7.0 you can emulate a web server by intercepting all URL requests and provide custom URL responses in both synchronous and asynchronous way.
Security:
@JsAccessible:
JxBrowser allows injecting Java objects into JavaScript and invoking its public methods from JavaScript code. For security reasons only public methods annotated with @JsAccessible can be accessed from JavaScript. The Java object’s fields are not accessible. If JavaScript calls the method that does not exist in the injected Java object or the method is not public and has not been annotated, then a JavaScript exception with an appropriate error message will be thrown.
Sandbox:
Sandbox on Windows is now enabled by default.
These are just the most notable changes. Please take a look at the new documentation portal for the full list of features and changes in JxBrowser 7.0.
Dropped Features:
Starting with this version JxBrowser no longer supports Oracle JREs 1.6 and 1.7, Apple’s and IBM’s JREs, macOS 10.9, and OSGi.
To release JxBrowser 7.0 sooner we temporarily dropped several more features. We plan to re-introduce them in the next releases.

New in JxBrowser 6.23.1 (Mar 22, 2019)

New in JxBrowser 6.23 (Feb 21, 2019)

Chromium 69:
In this JxBrowser release we decided to go for Chromium version 69.0.3497.12, since this build provides a range of much needed benefits -
It makes running JxBrowser on Linux easier as the libgconf system library is not a required library for Chromium anymore. So long to manual pre-launch installation!
It makes printing setup faster. Starting with this version Chromium got compatible with "Xerox global Print Driver PS". This universal printer driver lets you print to virtually any printer available, regardless of the manufacturer.
It displays the web pages as expected with zoom level != 100%, which was the issue in some previous Chromium builds.
It initializes as expected and works reliably in the medical diagnostics environments where the Software EEG Neurofax is installed.
It opens large JavaScript files without having debugging connection in DevTools closed.
Disabling Chromium Traffic:
Starting with this version you can disable Google traffic and prevent the Chromium engine from sending any data to a range of external Google web servers.
By default, Chromium may access the following Google domains to communicate with Google static or API servers -
clients1.google.com (for autofill form data)
ssl.gstatic.com (for "Safe browsing" functionality)
redirector.gvt1.com (for downloading Hunspell dictionaries on Windows and Linux).
This behavior might not be acceptable for a software used in the companies with high security standards.
To disable Google traffic to these servers, please set the --disable-google-traffic Chromium switcher before creating the first Browser instance in your application.
Improvements:
This version no longer triggers Windows Audit Failures. The issue was caused by Chromium calling the LogonUser() function from Windows API, and passing an empty password to it. We resolved the issue by disabling functionality that tries to log on using an empty password. This change does not affect any other Chromium functionality.
JxBrowser now uses absolute paths when executing the terminal commands such as ps, ln on Linux and macOS. With this security enhancement the library can be used under the Java Security Manager without providing <<ALL FILES>> execute permission.
Fixed issues:
The JavaScript Java Bridge is now restored correctly in case of an unexpected Main Chromium process termination. In order to do this JxBrowser detects an unexpected Main Chromium process termination, updates the internal state of the Java objects, and notifies the client code that the Browser instances running in the terminated process have been disposed.
PDF Viewer, file downloads, and the default zoom level functionality are now working properly in the Incognito mode.

New in JxBrowser 6.22.2 (Jan 10, 2019)

New in JxBrowser 6.22.1 (Dec 7, 2018)

New in JxBrowser 6.22 (Oct 24, 2018)

New in JxBrowser 6.21 (Jun 22, 2018)

New in JxBrowser 6.20 (May 4, 2018)

New in JxBrowser 6.19.1 (Mar 5, 2018)

New in JxBrowser 6.19 (Feb 27, 2018)

New in JxBrowser 6.18 (Dec 12, 2017)

We’re glad to announce, that starting with this release JxBrowser comes with Java 9 support! We have also included several more requested features and improvements into this version:
Java 9:
Now, JxBrowser can be used in Java desktop applications that are running on JRE 9.
Java 9 support has several limitations:
JxBrowser supports only Java 9 applications that don't use the Java Platform Module System. Support of the Module System will be added in one of the next versions.
JxBrowser doesn't support SWT+Java 9.
JxBrowser supports only default JVM parameters. If you modify default values (e.g.`--illegal-access=deny` instead of the default `--illegal-access=permit`) of the VM parameters, then the library might not work on JRE 9.
The rest of JxBrowser functionality is supposed to be working in the same way as on JRE 6, 7, 8.
U2F:
In this version we enabled support of the U2F authentication standard.
You don't need to configure the library or your Java application to support U2F. It works by default.
CacheStorage.clearHttpAuthenticationCache():
The API has been extended with new functionality that allows clearing HTTP Auth cache
Async Find Text:
In previous versions there was no way to cancel the current search until it was completed. In this version we extended the API with new functionality that allows performing text search on the loaded web page and being able to cancel it anytime.
Cookies Encryption:
Cookies are now can be encrypted. Unlike Chromium, JxBrowser does not encrypt cookies by default. To enable cookies encryption use the `--enable-cookie-encryption` Chromium switcher.
Also, on Linux, Chromium can store passwords in three ways:
GNOME Keyring
KWallet 4
plain text
Chromium chooses which store to use automatically, based on your desktop environment. Passwords stored in GNOME Keyring or KWallet are encrypted on disk, and access to them is controlled by dedicated daemon software. Passwords stored in plain text are not encrypted. Because of this, when either GNOME Keyring or KWallet is in use, any unencrypted passwords that have been stored previously are automatically moved into the encrypted store.
Although Chromium chooses which store to use automatically, the store to use can also be specified with a command line argument:
`--password-store=gnome` (to use GNOME Keyring)
`--password-store=kwallet` (to use KWallet)
Fixed issues:
The "IllegalStateException: HTML document isn't available" exception thrown sometimes when a new web page is loaded. The native crash when disposing `Browser` instance while there's an active printing job. Now, the pending printing jobs will be canceled when the `Browser` instance, which initiated the printing has been disposed.
The sporadic native crash on macOS and Windows when using the `Browser` instances in multi-threaded environment.
The issue with a single pixel white line at right and bottom of a Java frame running in the fullscreen mode on Linux.
The native crash in Chromium render process that happens when destroying `JSContext` instance in multi-threaded Java environment.
The native crash in Chromium main process on Linux platform with the AMD Radeon and nVIDIA GeForce GPU devices when running JavaFX application.
Passing a custom client SSL certificate to Chromium not having any effects unless the certificate is registered in OS.
Improvements:
Chromium binary files have been signed using time-stamping. In previous builds, the binary files were signed with the TeamDev certificate that is valid until April 25, 2018. Time-stamping wasn't used during signing, so the signature will be invalid starting the next day.
The fix that resolves the Chromium vulnerability CVE-2017-5124 (Chromium 62) has been back-ported to Chromium 60 used in JxBrowser 6.18.
We have also improved performance when finding text with the same search request on the loaded web page multiple times.

New in JxBrowser 6.17 (Nov 6, 2017)

JxBrowser 6.17 lists quite a number of new features and improvements:
Sandbox on Windows:
In this version we have added support of the Chromium Sandbox on the Windows platforms.
By default, Sandbox is disabled to save backward compatibility with the previous versions. To enable Sandbox set the jxbrowser.chromium.sandbox System Property to true before you create a first Browser instance.
Improvements:
From this version on JxBrowser support page ranges when saving PDF as PDF document. Partial content printing also became possible.
We take stability seriously, so this release can boast improved stability in multi-threaded environment when disposing the Browser instance, and enhanced stability of the Chromium engine when submitting a credit card credentials on a payment portal web page.
And a couple more convenient improvements in this version:
The DefaultDialogHandler Swing implementation now respects Swing's EDT-Rules and disables UI dialogs in EDT.
The debug.log file generation on Windows 7 and 8/8.1 has been disabled.
Fixed issues:
Black screen and flickering during resizing BrowserView in the heavyweight rendering mode on Windows platforms.
IllegalArgumentException exception thrown when providing a valid language through the --lang Chromium switcher.
The unexpected ConcurrentModificationException exception thrown from the internal NetworkDelegate implementation.
Rotation not working for drop downs with the lightweight rendering mode in JavaFX application.
Two-sided checkbox not working on the default Swing print dialog.
The selected printer name not being applied in the default JavaFX and Swing print dialog implementations.
The window.outerHeight JavaScript code always returning 0 in the lightweight rendering mode.
BrowserContext duplicating Chromium data, cache, and memory directories when a relative path is provided.
Printing SVG content on Windows platform. It was broken because of disabled Chromium Sandbox. Some SVG content requires that Chromium Sandbox is enabled to correctly print SVG content.
The Browser.invokeAndWaitFinishLoadingMainFrame() method never ending if loading failed.
Hovering the mouse over a re-sizable data grid header not changing the cursor.

New in JxBrowser 6.16 (Oct 5, 2017)

New in JxBrowser 6.15 (Sep 14, 2017)

We'll get straight to the point: Chromium 60.0.3112.113 is implemented in JxBrowser 6.15!
The new version also lists some cool new features, and important improvements.
Here's a detailed record of what's changed:
Chromium 60:
The Chromium engine is upgraded to version 60.0.3112.113. It means that support of WebGL 2.0 has been automatically enabled.
Due to Chromium engine upgrade the list of supported platforms have been changed as well. Some time ago, the Chromium team announced that they will end support for Google Chrome on 32-bit Linux, Ubuntu Precise (12.04), and Debian 7 (wheezy) in early March, 2016.
With Chromium upgrade to version 60, we drop support of Ubuntu Precise (12.04), Debian 7 (wheezy) both 32-bit and 64-bit, and all 32-bit Linux distributions as well. Now, JxBrowser supports only 64-bit Linux.
DOMNode.getXPath():
The DOMNode.getXPath() method that allows getting XPath for the given DOMNode has been implemented.
Browser.setUserAgent(String userAgent):
The Browser.setUserAgent(String userAgent) method was added. It provides an ability to change user agent string runtime without re-creating Browser instance.
Browser.setAcceptLanguage(String acceptLanguage):
The Browser.setAcceptLanguage(String acceptLanguage) method was added. It allows changing accept language string runtime.
ProxySerivce:
A long awaited functionality that allows modifying proxy settings runtime is now available in JxBrowser. Now, you can change proxy settings runtime for specific BrowserContext instance. The new proxy configuration will be applied automatically to all Browser instances associated with the BrowserContext.
<input> accept attribute:
The FileChooserParams.getAcceptableExtensions() method was added. This method returns HTML <input> accept attribute value. Default implementation of the DialogHandler interface for both JavaFX and Swing have been updated, so that they support this attribute, and filter the files in the dialog according to the given extensions.
Pinch to zoom:
The --disable-pinch switcher now can be used to disable pinch to zoom on macOS when using trackpad. This functionality is supported only by JxBrowser. Google Chrome doesn't allow disabling pinch to zoom on macOS when using trackpad.
Improvements:
Startup time on Windows is decreased.
Extra log messages printed into console output on macOS even when logging is disabled were removed.
Fixed issues:
JavaScript mouse event listener receiving incorrect mouse button.
DialogHandler.onBeforeUnload() method not being invoked when disposing Browser.
The default BrowserContext instance always creating empty directories in user's temp directory.
RejectedExecutionException exception being thrown from internal logic.
An internal issue with the OnPaint message deserialization.

New in JxBrowser 6.14.2 (Jun 23, 2017)

New in JxBrowser 6.14.1 (Jun 7, 2017)

New in JxBrowser 6.14 (Apr 13, 2017)

Injecting custom style sheet (CSS):
Now you can inject a custom style sheet into every web page loaded in JxBrowser. In order to inject CSS use the Browser.setCustomStyleSheet(String customStyleSheet)method. Once you set a string that represents CSS, all web pages loaded in this Browser instance will be updated with the given CSS. See example to get more details on how to use this functionality.
Injecting custom SSL certificate:
The DialogHandler.onSelectCertificate(CertificatesDialogParams params)method allows selecting SSL certificate from the list of installed certificates. Now, you can tell Chromium engine to use SSL certificate that isn’t installed in your environment.
Accessing Browser in NetworkDelegate events:
A lot of developers requested that we provide an ability to associate Browser instance with HTTP request/response. Now you can do that. See the RequestParams.getBrowser()method.
Improvements:
Added Chromium profile directory validator. In general, Chromium engine doesn’t allow running several processes or BrowserContext instances configured to the same profile directory. Sharing profile directory between different native processes and BrowserContext instances may lead to unexpected behavior including crashes in Chromium engine. To protect Java application from the unexpected crash in Chromium engine, since 6.14 version JxBrowser checks whether Chromium profile directory is already used by another BrowserContext instance or native process, and throws an exception if Browser instance cannot be configured to use the given profile directory.
Improved Chromium binaries validation. JxBrowser allows configuring the path to the directory where it should find/extract Chromium binaries. If the directory already contained Chromium binaries, then old validator implementation simply checked the existence of the required Chromium files. Now, JxBrowser validates that the Chromium binaries in the directory not only exist but also correspond to the current JxBrowser version. So, the situation when old Chromium binaries are used with new JxBrowser library won’t happen.
Fixes:
The issue when the Event.dataTransfer.setDragImage() JavaScript method invocation causes crash in Chromium engine on macOS.
The issue when some CSS cursors such as zoom in, zoom out, etc. aren’t supported in heavyweight rendering mode.
Wrong scrolling in SWT-JavaFX applications on macOS.
Wrong cursor location in JavaFX applications with enabled lightweight rendering mode.
The issue when the drop down doesn’t work in JavaFX TabPane with enabled lightweight rendering mode.
Wrong scaling in the multi HiDPI/Non-HiDPI monitor environment on macOS and Windows in both lightweight and heavyweight rendering modes in JavaFX and Swing.
Improved stability in the multi-threaded environment.
Smooth font rendering in heavyweight and lightweight rendering modes on Windows.
Wrong BrowserView location in JavaFX SplitPane in heavyweight rendering mode on Windows.
Memory leak when using JSObject.setProperty().
Native crash when calling JSObject.removeProperty().
The "Go Forward" button in JxBrowser Demo is disabled when should be enabled.
Broken rendering in drop downs in JavaFX and Swing with enabled lightweight rendering mode.
Java 9 isn’t recognized properly. Now you can launch JxBrowser on Java 9 without unexpected environment validator exceptions.
Broken file upload functionality.
File chooser dialog isn’t displayed in IFRAMEs.
Broken JavaFX lightweight rendering with low RAM.
Broken JavaFX lightweight rendering when resizing BrowserView.
Default print dialog allows printing only 100 pages.
WebStorage doesn't work until it's initialized from JavaScript.
The BrowserPreferences.setDefaultEncoding()method should be marked as deprecated because Chromium 55 ignores encoding settings.
Drop down is not closed when moving JavaFX window in heavyweight rendering mode.

New in JxBrowser 6.13 (Feb 28, 2017)

NEW FEATURES:
Creating and dispatching DOM events:
In this version JxBrowser DOM Events API is extended with new methods and classes, which allow creating and triggering DOM events at the specified HTML element. Starting from v6.13 JxBrowser supports the Event, UIEvent, MouseEvent, and KeyEvent DOM events. To dispatch an event use the DOMEventTarget.dispatchEvent(DOMEvent event) method.
WebRTC IP handling policy:
The BrowserPreferences class is extended with the setWebRTCIPHandlingPolicy(WebRTCIPHandlingPolicy policy) method that allows configuring WebRTC IP handling policy. The list of supported policies is available in the WebRTCIPHandlingPolicy enum.
No pain with OS detection in old JREs:
The environment validation algorithm is improved. JxBrowser detects OS name and version using standard Java system properties such as “os.name” and “os.version”. Old JREs such as 1.6 don’t recognize modern operating systems and detect them as “Windows NT (unknown)” which leads to the “com.teamdev.jxbrowser.chromium.internal.EnvironmentException: Unsupported operating system. Supported OS: Windows 7, 8, 10, Windows Server 2008 R2, 2012, 2016, macOS 10.9+ & Linux. Current OS: Windows NT (unknown), version: 6.2” exception. The workaround was to manually set “os.name” to a string that contains supported operating system name such as “Windows 7” or “Windows Server 2016”. This workaround wasn’t convenient for JxBrowser customers.
In this update we made environment validation less strong. Now, JxBrowser checks only minimal supported OS and JRE version. It allows using the library with old JREs such as 1.6 on modern operating systems such as Windows Server 2016 without any workarounds or manipulations with the “os.name” system properties.
IMPROVEMENTS:
JAWS support in heavyweight rendering mode.
Memory usage on Windows, macOS and Linux platforms. We discovered and resolved several memory leaks related to lightweight rendering mode, virtual memory usage, internal IPC implementation, JNI code, etc.
FIXES:
The deadlock issue during drag and drop on macOS and Windows platforms in both Swing and JavaFX views. It was caused by a logical error in drag and drop implementation on Java side in lightweight rendering mode.
The regression issue when mouse and keyboard events are not fired in heavyweight rendering mode is fixed. The issue arose after upgrade to Chromium 55. Now, this functionality works exactly as in previous JxBrowser versions based on previous Chromium builds.
The issue when the onblur event isn’t fired when BrowserView lost focus.
The issue when the “java.lang.IllegalArgumentException: The certificateStr cannot be null or empty” exception is thrown when loading HTTPS web pages.
The regression issue when DownloadItem.setDestinationFile() is ignored.
The issue when mouse clicks are ignored in drop downs and are not recognized by some JavaScript libraries such as Hammer.js in the lightweight rendering mode is resolved. It was a regression issue after upgrade to Chromium 55. Now, this functionality works as expected.
This update addresses the rendering issues on macOS and Windows in lightweight rendering mode in both Swing and JavaFX views. The rendering issues used to happen during resizing browser view, displaying drop downs, after disposing and creating Browser instances, on Windows platforms with HiDPI monitors. There were several root causes of the rendering issues. All of them are fixed in this version.

New in JxBrowser 6.12 (Jan 26, 2017)

New in JxBrowser 6.11.1 (Jan 11, 2017)

New in JxBrowser 6.11 (Dec 31, 2016)

New in JxBrowser 6.10 (Dec 14, 2016)

New in JxBrowser 6.9 (Nov 30, 2016)

New in JxBrowser 6.8 (Nov 17, 2016)

Version 6.8 includes quite a number of the new features and improvements:
HTML5 Desktop Notifications API. Now you can handle situation when a web page wants to display desktop notifications. You decide whether the web page is allowed to display notifications or not. By default, desktop notifications are suppressed.
Incognito mode. By default, each Browser instance stores all user data such as history, cookies, cache on disk. Starting from version 6.8 you can configure Browser instance to store all user data in memory (Chromium's "Incognito" mode), so that all user data will be cleared once your Java application is terminated. Read more.
Voice recognition. This functionality is used in Google’s search by voice. By default, voice recognition functionality is enabled, but it requires that Chromium Speech API key is enabled. So, you must provide Google API key to enable search by voice functionality in JxBrowser. Read more.
The Browser.getRenderProcessInfo() method. It returns information about Chromium render process associated with the current Browser instance. You can use this functionality to get process ID of Chromium render process associated with the Browser instance. Read more.
HTTP server whitelist functionality. Read more.
The BrowserView.forwardKeyEvent() method for JavaFX and Swing implementations. This method allows programmatically forward keyboard events to the currently loaded web page.
The Environment.isSupported() method. It allows checking whether current environment is supported by JxBrowser or not.
JavaScript – Java Bridge API has been extended with functionality that allows obtaining Java object from JSValue, if JSValue represents a JavaScript wrapper for Java object. Read more.
JavaScript – Java Bridge API has been extended with functionality that allows configuring what public fields/methods of the injected Java object are accessible from JavaScript and what fields/methods are not. Read more.
Functionality that allows taking screenshots of the entire web page has been improved. There was a limitation in Chromium engine related to maximum texture height of the Browser surface where the web page’s content is rendered. If the texture height exceeds the maximum value (16384), Chromium engine fills the rest of the web page with black color. Now you can configure the maximum texture height programmatically depending on your requirements. Read more.
Support of the file extension filter in the File Save dialog has been added in the com.teamdev.jxbrowser.chromium.javafx.DefaultDownloadHandler implementation.
This update also contains fixes for the following issues:
The crash when loading PDF document several times in a row.
The focus isn’t restored when Scene is added back to Stage issue.
The focus doesn’t work in JavaFX TabPane issue.
The issue when IllegalStateException is thrown during processing callbacks during disposing Browser instance.
The memory leak when disposing Browser instance.

New in JxBrowser 6.7.1 (Oct 7, 2016)

New in JxBrowser 6.7 (Sep 16, 2016)

Let us provide you with more details of what has been improved:
We have added functionality that allows enabling/disabling zoom for a Browser instance. Now you can disable zoom functionality for a specific Browser instance to prevent web page from zooming via zoom in/out/reset functions or via touch gestures on the touch screen devices. Read more.
The new version now features functionality that allows getting notifications when web page becomes unresponsive/responsive. Read more.
Support of HiDPI monitors on Windows platforms has been improved. Several developers reported the issue with positioning BrowserView component inside Java frame on HiDPI monitors on Windows platform. The issue is reproducible only when system font scale factor is != 100% and Java process doesn’t have the DPI Awareness flag in the process’ manifest. So, they were running Java program using patched java.exe where the DPI Awareness flag is removed. JxBrowser Chromium process has the DPI Awareness flag in the process’ manifest. Thus, it leads to the situation when Java and JxBrowser Chromium processes are differently configured. To solve the issue we need to run JxBrowser Chromium process with the same DPI Awareness flag value. We updated code in JxBrowser Chromium process, so that it programmatically detects whether the flag is set in Java process and configures JxBrowser Chromium process accordingly.
JavaScript-Java Bridge API has been extended. We added functionality that allows setting items to JSArray at specific index, implemented support of access to (ability to modify) public field of injected Java object into JavaScript code, and added the ability to instantiate JavaScript objects in Java code.
The DOMElement.getBoundingClientRect() method has been implemented. This method allows getting bounds of the element and its position relative to the top-left of the viewport of the current document. Read more.
The Browser.forwardKeyEvent() method has been added. This method allows forwarding keyboard events to the currently loaded web page. It’s very useful when using JxBrowser in a kiosk Java application that must run on terminals with touch screen. Read more.
Size of JxBrowser JAR files has been reduced by ~30% by using a better compression algorithm for archiving Chromium binaries.
Default logging level has been changed to SEVERE instead of ALL. According to your feedback, you prefer that JxBrowser doesn’t print all log messages into console output by default.
Default popup window title has been changed. Now, popup window title displays the currently loaded document’s title. If the document’s title represents an empty string, the popup window title will be empty as well. It will not display the “JxBrowser Popup” text like in previous versions.
We have removed TeamDev’s signature from JAR files. Starting from this update we decided to ship JxBrowser as a set of unsigned JAR files. From the support requests we noticed that signed JAR files cause deployment and modification issues for developers. The developers cannot modify Manifest files of the signed JxBrowser JAR files or combine them into a single JAR. When they deploy JxBrowser in their JWS application, then have to remove TeamDev’s signature and sign JxBrowser JAR files with their own signature. To get rid of these little big issues, we decided to remove signature from JxBrowser JAR files to make life of Java developers easier. You can still download JxBrowser distribution package with signed JAR files from http://cloud.teamdev.com/downloads/jxbrowser/jxbrowser-x.x.x-cross-desktop-win_mac_linux-signed.zip, where the x.x.x must be replaced with an actual JxBrowser version.
The version introduces fixes for the following issues:
The StringIndexOutOfBoundsException error when calling the DOMElement.getAttributes() method.
The “IllegalArgumentException: Unsupported value: 17” error when loading web page.
The issue when printer prints documents in color when the “Black and White” option in default Print dialog is selected. The issue was in incorrect print setting flag sent to Chromium engine during printing.
The issue when render process is unexpectedly terminated when calling the DOMElement.hasProperty() method.
The issue when keyboard shortcuts such as Cmd+A, Cmd+C, Cmd+V, Cmd+X, Cmd+Z, Cmd+Y don’t work on macOS when CapsLock is on.
Stability of the library in multi-threaded environment when creating a number of Browser instances with unique BrowserContext.

New in JxBrowser 6.6.1 (Aug 10, 2016)

In this minor update we fixed several critical issues reported by our customers and improved existing functionality:
Felix and Eclipse OSGi. JxBrowser has been adopted and tested in Felix OSGi environment. Now JxBrowser supports two OSGi implementations: Eclipse and Felix. Eclipse OSGi environment support has been improved as well. Now, each JxBrowser JAR file represents an OSGi bundle. To use JxBrowser in your OSGi application, you just need to include JxBrowser JAR files/bundles into your OSGi application.
Spell Checker API. By default, Chromium engine does spell checking only for the text in the modified paragraph. In this version we introduced functionality that forces Chromium engine to spell check the whole text upon every change including text in TinyMCE editor.
JavaScript-Java Bridge API. Using JavaScript-Java Bridge you can inject Java object into JavaScript code and associate it with JavaScript object’s property. When Java object is injected into JavaScript code via the bridge, JavaScript code can access only public methods of the Java object. When Java object represented a class that inherited another class with public methods, there was no way to access public methods of the parent class. Starting from version 6.6.1 you can access all public methods of the registered Java object, including parent’s methods.
Printing API. Support of page ranges when printing web page as PDF document has been implemented.
Deadlock in multi-threaded environment on Windows XP and OS X. In multi-threaded environment, when Browser instances are created and destroyed in different threads at the same time, sometimes thread deadlock happens. We reproduced the issue, figured out what causes it and fixed it in this minor update. So, stability of the library in multi-threaded environment on Windows and OS X was significantly improved.
Deadlock during Drag and Drop on Windows. The issue happens when dragging something in Java application and displaying BrowserView without releasing the drag. It was simple thread deadlock that is now fixed in JxBrowser code.
Printing in PDF Viewer. An issue when empty page was printed when printing from PDF viewer is fixed.
Zoom in/out in PDF Viewer. An issue when the Browser.zoomIn() and Browser.zoomOut() methods do nothing when PDF document is displayed in PDF Viewer is fixed.
Failed to load PDF document in PDF Viewer. If we load the http://www.orimi.com/pdf-test.pdf web page, click the link in the document, wait until web page is loaded completely, and then press backspace, we will see the “Failed to load PDF document” error message. The issue is fixed in this update.
Render Process events. It turns out that the RenderListener.onRenderGone() event is fired only when lightweight rendering mode is enabled. In heavyweight rendering mode there was no way to find out when render process is unexpectedly terminated. Now the event is fired in both rendering modes: heavyweight and lightweight.

New in JxBrowser 6.6 (Aug 10, 2016)

Upgrade to Chromium 51:
The major change in this release is upgrade of the Chromium engine to version 51.0.2704.106, which also brings several changes to JxBrowser system requirements.
In November 2015 Google announced the end of Chrome/Chromium’s support for Windows XP, as well as Windows Vista, and Mac OS X 10.6, 10.7, and 10.8, since these platforms are no longer actively supported by Microsoft and Apple. Starting with Google Chrome/Chromium 50 these platforms are no longer supported at all. Since JxBrowser 6.6 is based on Chromium 51, support of these platforms has been dropped as well.
Fixes and Improvements. Here is a detailed overview of the features added in JxBrowser 6.6:
SpellCheck events. This API allows registering SpellCheckListener for receiving notification about spell check results on the loaded web page. When a text field or text area on the loaded web page receives focus, Chromium’s spell checker functionality automatically checks the text and highlights misspelled words. Using the SpellCheckListener you can obtain the information about misspelled words as well. See example.
Multiple webcams. Now you can display video from several webcams on a single web page at the same time.
The "Ignoring too frequent calls to print()" error message when printing too often has been disabled. By default, Chromium doesn’t allow calling print functionality too often. If you try to print web page more than one time per 2-3 seconds, Chromium will throw the "Ignoring too frequent calls to print()" error message in JavaScript console and cancel printing. Now, you can call print functionality as often as you need.
The issue when popup window could not be closed in JavaFX with enabled heavyweight rendering mode has been resolved. The issue lied in GUI threads conflict between JavaFX and Chromium native widgets, which is fixed now.
Native crash on Ubuntu 14.04 32-bit and 64-bit when displaying a custom cursor on a web page has been fixed. This issue was reproducible only when heavyweight rendering mode is enabled. To fix the issue we applied several patches to JxBrowser code that works with Chromium native widgets on Linux.
The issue when clicking the Download button in PDF Viewer did not actually download PDF document has been fixed. It was reproducible in a very specific situation when pressing the Download button sends HTTP request to a web server that returns PDF document in HTTP response body. We figured out that in HTTP request, JxBrowser sends incorrect user agent string which causes web server to return 500 HTTP status code. We fixed the issue with wrong user agent string in HTTP request headers and it solved the issue.

New in JxBrowser 6.5.1 (Aug 10, 2016)

New in JxBrowser 6.5 (Aug 10, 2016)

Key Changes:
In this update we focused on implementing features, long-awaited by our customers, such as access to HTTP response data (AJAX response body), multiple HTTP headers support, gesture event listener, getting selected HTML, better support of IME and different keyboard languages, and much more.
Features and Improvements. Here is a detailed overview of the features added in JxBrowser 6.5:
The NetworkDelegate.onDataReceived(DataReceivedParams params) method. This method is invoked each time, when response body or its part is received. It means that now you can get the data of each HTTP response including HTML, plain text, image binaries, etc. You can use this functionality to access AJAX response body as well. See example.
The HttpHeadersEx class. The HttpHeaders (deprecated starting with version 6.5) class allowed to get only one HTTP header value by name. It made impossible getting multiple HTTP header values, in cases when HTTP header has several values for the same name. The HttpHeadersEx class solves the issue by allowing to access multiple values of HTTP header with the same name.
Support of paper size setting for saving web page as PDF document. In previous JxBrowser versions the paper size for this case was hardcoded to A4 format. Now, you can use any paper size.
Ability to specify custom paper size for printing a page. Now, you can specify your own paper size in millimeters or inches when printing a web page.
Functionality that allows getting selected HTML on the loaded web page. See example.
The getContentLength(), getCharset(), getMimeType(), getStatusLine() methods in the HeadersReceivedParams class. As an example, in order to get information about the response status code and the reason phrase you can use the getStatusLine() method.
The Browser.isAudioPlaying() method. Using this method you can determine whether audio is playing at the moment on the loaded web page or not.
The BrowserView.setGestureEventsHandler() method. When registered, it allows you to handle gesture events when heavyweight rendering mode is enabled in both JavaFX and Swing implementations. In lightweight rendering mode this handler isn’t used.
Support of multiple displays with different device scale factor in lightweight JavaFX BrowserView component. In previous JxBrowser versions, if you moved JavaFX scene/window with embedded lightweight BrowserView component from a regular display to Retina display, the rendering would not be optimized for Retina display. As a result, you’d get a blurred image of the loaded web page. Now, the library detects when a component is moved from one display to another and updates lightweight rendering parameters to produce a picture of a web page with the best quality for a display where the component is shown at the moment.
Support of File Save dialog. We figured out that some Flash content can display a File Save dialog which isn’t supported in default DialogHandler implementation. In this update we fixed this issue, so now the File Save dialog is supported.
Support of all Chromium process types by the crash dump file generation. In previous JxBrowser versions, we generated crash dump file for the main Chromium process only. In case of crash in the renderer or GPU Chromium process, the crash dump file wasn’t generated at all.
JxBrowser 6.5 provides fixes for the following issues:
Chromium engine modifying the number of maximum opened files in Java process on Mac OS X (ulimit -n). On Mac OS X Java process can open 10240 files/streams at the same time. We noticed that when a Browser instance is initialized in Java process, the value is changed to 1024. The reason lied in Chromium engine that modified the value during initialization. Now, Chromium engine checks the initial value first, and modifies it only if it’s greater than 1024.
Printing doesn’t work in a popup window. It was a regression issue after upgrade to Chromium 49. Now, everything works like a charm.
System keys (e.g. Alt, Cmd, Control, Shift) support in German keyboard on Mac OS X. The issue was reproducible in the lightweight rendering mode only. We fixed the issue and made sure that other keyboards work on Mac OS X as expected.
Chromium crashes with out of memory error when saving large HTML document (20MB+) as a PDF document or displaying popup window with a big image on Windows. To fix the issue we use the /LARGEADDRESSAWARE linker flag when building JxBrowser on Windows. The same flag is used in the official Chromium build.
“java.awt.IllegalComponentStateException: component must be showing on the screen to determine its location” error that comes from BrowserView component when heavyweight rendering mode is enabled on Windows.
“IllegalArgumentException: Unsupported type: :” error when sending emoji via JavaScript–Java Bridge. The issue was caused by the incorrect string length for emoji symbols on Mac OS X.
Support of screen keyboard on Windows 8+ touch devices has been improved. We figured out that when BrowserView component was activated via mouse click, screen keyboard worked fine and we could type in a text field on the loaded web page in JxBrowser. But when BrowserView component was activated via tap/touch event, BrowserView component didn’t receive focus. As a result the user could not type in a text field on the loaded web page using screen keyboard. In this update the issue has been fixed and the screen keyboard interacts with JxBrowser exactly as with Google Chrome.
Drop down not appearing in the fullscreen mode. The issue was reproducible in the heavyweight rendering mode. We have patched the Chromium engine for the drop downs to work as expected in the fullscreen mode.
Impossible to access the radio buttons, checkboxes, and buttons or select them via Space key when IME (Japanese, Pinyin) is active. In previous JxBrowser versions we didn’t update IME state when focus went to radio button or checkbox. Now, this functionality works exactly as in Google Chrome.

New in JxBrowser 6.4 (Aug 10, 2016)

Chromium 49:
JxBrowser 6.4 is based on Chromium 49.0.2623.110
This is fairly cool, because apart from general compatibility with the latest web standards, this Chromium engine solves tricky tasks, which were hard to accomplish in some previous versions, like displaying WebGL content on Linux platforms, and enabling incoming audio RTP streams. Also, in Chromium 49, PDF Viewer UI has been updated. So, now you can enjoy the new look, when displaying PDF documents in JxBrowser
Plugins support:
There were some big changes, too. In this Chromium build support of NPAPI plugins has been removed at all. Now, NPAPI plugins such as Microsoft Silverlight, Java Applets, etc. are not supported. The “--enable-npapi” Chromium switcher doesn’t work either. PPAPI plugins such as Adobe Flash work well with this Chromium build. So, if you have to use NPAPI plugins, we recommend that you stick to JxBrowser versions up to 6.4
Further plans on OS support:
Chromium team announced that Chromium 50 drops support of Windows XP, as well as Windows Vista, and Mac OS X 10.6, 10.7, and 10.8, since these platforms are no longer supported by Microsoft and Apple. So here we are giving you a heads up related to these platforms, and we will, too, let them rest in peace, when we are ready with the oncoming update based on Chromium 50 or higher
Features & Improvements:
WebGL on Linux support has been added. In previous JxBrowser versions, WebGL didn’t work on Linux platforms, because Chromium didn’t start GPU process for rendering WebGL content. Once we upgraded to Chromium 49, WebGL started working as expected on Linux platforms
In JxBrowser versions based on Chromium 43, there was an issue related to incoming audio RTP streams support. Alas, it just doesn’t work with Chromium 43. With Chromium versions before 43 and Chromium 49 this issue isn’t reproducible. So, now incoming audio RTP streams are officially supported in JxBrowser
Below let us list the issues that, however, no longer endanger your development process:
The placeholder text used to stay visible while a user was already typing in a text area. Happy to say it doesn’t in the new release
A surprising black rectangle used to show up instead of a scroll bar when a PDF Viewer window was resized. This issue was reproducible only on Windows 8.1 and higher. Upgrade to Chromium 49 fixes this issue
You will not see the IllegalArgumentException error when you right-click PDF Document
No more native crashes in Chromium renderer process, at least not when your app finds a DOM HTML element by ID string with a single quote. The issue was in WebKit DOM functionality that didn’t handle such situation. We applied several patches to WebKit source code that fix the issue
You have no installed printer devices? This is not a reason for failing of the printing functionality on Linux. Now, if there’s no available printer devices, we don’t ask Chromium engine to print web page at all. To print web page using printer, at least one printer device must be installed
Deadlock in JavaScript-Java Bridge used to happen under several circumstances. For example, when loading XML document and executing JavaScript code in the ScriptContextListener.onScriptContextCreated(ScriptContextEvent event) method. If we execute JavaScript code in XML document, it will be executed in a separate JavaScript world. As result, the ScriptContextListener.onScriptContextCreated(ScriptContextEvent event) method is invoked again and the code will be blocked in the synchronized Browser.executeJavaScriptAndReturnValue() method. To solve this issue we enabled reentrancy support in JxBrowser IPC functionality and modified synchronization logic in the Browser.executeJavaScriptAndReturnValue() method
BrowserView now retains its focus context, even after showing/hiding the context menu, so users can type texts in the text field normally after closing the context menu. The issue has been fixed by updating focus context info when showing/hiding context menu
In multi-threaded environment we used to see see the “Deadlock in safepoint code” error that came from JxBrowser JNI code. To fix this issue we made sure we create and access JNIEnv variable in the same thread

New in JxBrowser 6.3 (Aug 10, 2016)

New in JxBrowser 6.2 (Aug 10, 2016)

New in JxBrowser 6.1.1 (Aug 10, 2016)

New in JxBrowser 6.1 (Aug 10, 2016)

JavaScript-Java Bridge API has been improved. Now API allows injecting any Java objects into JavaScript code on the loaded web page and calling Java object’s methods directly from JavaScript.
The ScriptContextListener has been implemented. It allows getting notifications when web page has been loaded but JavaScript on it hasn’t been executed yet.
LocalStorage and SessionStorage API has been implemented.
Functionality that allows accessing PUT and PATCH data of HTTP request’s body has been implemented.
Functionality that allows getting frame IDs hierarchy on the loaded web page has been added.
PluginManager API has been extended with additional methods. Now you can get information about plugin type and check whether Chromium supports NPAPI plugins or not.
Certificate API has been extended with additional methods that allow getting more information about SSL certificate.
Communication between Java and Chromium processes is based on shared memory now (instead of sockets in previous versions). Data transferring between Java and Chromium processes now works ~10 times faster.
Stability in multi-threaded environment has been improved.
Support of CSS cursors has been improved in HEAVYWEIGHT rendering mode.
Fixed issue when the IndexOutOfBoundsException error is thrown popup window is closed [swing, heavyweight].
Fixed issue when the “IllegalStateException: Channel is already closed” error is thrown when Browser instance is created.
Fixed issue when Mouse & Keyboard events are not fired [javafx, heavyweight, lightweight].
Fixed issue when Tooltips aren’t shown on Windows [javafx, swing, heavyweight].
Fixed incorrect behavior when pressing arrow down/up keys moves cursor two fields down/up in drop down menu [javafx, lightweight].
Fixed issue when user cannot set focus to BrowserView in JavaFX TabPane [javafx, heavyweight].
Fixed issue when some Flex/Flash content doesn’t work correctly and causes JavaScript errors [swing, javafx, heavyweight, lightweight].
Fixed issue with memory usage when reloading content of an IFRAME on loaded web page.
Fixed crash in Chromium engine when page title is being updated [swing, javafx, lightweight].
Fixed crash in Chromium engine when popup window is opened and its document is modified via document.write() JavaScript function.
Fixed crash in Chromium engine when SSL Certificate dialog is closed by pressing Cancel button.
Fixed crash in Chromium engine when showing/hiding Scene in JavaFX application [javafx, heavyweight].

New in JxBrowser 6.0.2 (Jan 7, 2016)

New in JxBrowser 6.0.1 (Dec 29, 2015)

New in JxBrowser 6.0 (Dec 14, 2015)

Heavyweight GPU-accelerated rendering mode has been added
Support of Citrix environment has been added
Support of SOCKS protocol in Proxy functionality has been added
Support of Maven projects has been added. See instruction about how to use JxBrowser in Maven project
The JSArray and JSDictionary types in JavaScript Java Bridge API has been added
JavaScript Java Bridge performance has been improved. Now it works ~10 times faster
Support of passing JSON string to JavaScript side via JavaScript Java Bridge has been added
The NetworkDelegate.onPACScriptError() event has been implemented
Support of Accessibility on Windows and Mac has been implemented [heavyweight, swing, javafx]
Support of CJK Input on Windows and Mac has been added [heavyweight, swing, javafx]
Support of --disable-direct-write Chromium switcher has been added [heavyweight]
Support of SWT environment has been implemented [heavyweight, swing, javafx]
Fixed issue with missing Move cursor on Mac [lightweight, swing, javafx]
Fixed issue with wrong key codes on Mac [lightweight, swing, javafx]
Fixed issue with wrong cursor names in the cursors.properties file [lightweight, swing, javafx]
Fixed issue with wrong custom cursor location [lightweight, swing]
Fixed issue with incorrect target in DOMEventListener
Fixed issue when video at vimeo.com doesn’t work
Fixed issue when it’s possible to type text when Alt key is pressed [lightweight]
Fixed issue when print to PDF fails when pages count is 0
Fixed issue when closing popup with PDF document leads to crash [heavyweight, swing, javafx]
Fixed issue when menu item doesn’t dismiss when click BrowserView control [heavyweight, swing, javafx]
Fixed deadlock when Browser displays default SSL certificate dialog [heavyweight, swing, javafx]
Fixed issue when multiple Browser instances cannot be configured to have their own proxy settings
Fixed NoSuchMethodException on Mac when JxBrowser is used in Java Applet [heavyweight, lightweight, swing, javafx]
Fixed NullPointerException in the BrowserPreferences.getDefaultAcceptLanguage() method
Chromium UI language by default is configured according to Java UI language
The Trusted-Library attribute in JAR manifest files has been removed
The debug.log file generation on Windows has been disabled
Symlink for libcrypto.so.1.0.0 on Linux has been added
In case of native crash in Chromium process on Windows, the library generates the jxbrowser-chromium.dmp file and stores it in %localappdata% directory (e.g. c:\users\\appdata\local\jxbrowser-chromium.dmp)

New in JxBrowser 5.4.3 (Sep 3, 2015)

New in JxBrowser 5.4.2 (Aug 7, 2015)

New in JxBrowser 5.4.1 (Aug 4, 2015)

New in JxBrowser 5.4 (Jul 23, 2015)

New in JxBrowser 5.3 (Jun 24, 2015)

New in JxBrowser 5.2.1 (May 19, 2015)

New in JxBrowser 5.2 (Apr 20, 2015)

New in JxBrowser 5.1 (Mar 23, 2015)

New in JxBrowser 5.0 (Feb 19, 2015)

New in JxBrowser 5.0 Beta (Jan 15, 2015)

JAVAFX:
Now, apart from Swing component, JxBrowser provides another one, that is designed for JavaFX applications. This new component allows to embed JxBrowser into JavaFX application like any other standard JavaFX component. Now Java developer should decide which component is to be used in their Java application. If Java application is based on Swing/AWT, then Swing component must be used. In case of JavaFX — JavaFX component.
JSOBJECT:
In 5.0 API we introduced two new objects: JSObject and JSFunction. So, now you can work with JavaScript objects and functions directly from Java code.
RESOURCE INTERCEPTOR:
With ResourceHandler you can get information about every resource that Chromium engine is going to load and decide whether it should be suppressed or not.
OSGI:
JxBrowser 5.0 JAR files contains the required for OSGi bundles information, so you can use them in OSGi environment as well.
CPU/MEMORY USAGE:
We also improved CPU and memory usage of JxBrowser library. Now, when UI component that displays web page isn't visible, it doesn't allocate memory for web page rendering. It allows significantly decreasing CPU and memory usage of your Java application.
Google API Keys:
With the BrowserPreferences.setChromiumVariable() method you can configure Chromium engine with specified API Keys such as Geolocation Keys (GOOGLE_API_KEY, GOOGLE_DEFAULT_CLIENT_ID and GOOGLE_DEFAULT_CLIENT_SECRET) that allows enabling Geolocation API in Chromium engine.
DOM Events:
We added new classes and methods to JxBrowser DOM Events API. Now you can get more information about DOM event and, if it's a mouse or keyboard event, you can get additional information about mouse location, button, key code, etc. Also we introduced two new methods in DOMEvent: stopPropagation() and preventDefault().
Features & Improvements:
The DownloadItem.cancel() | pause() | resume() | isCanceled() | isPaused() methods have been implemented.
The DefaultDownloadHandler has been improved. It checks permissions of the selected directory and informs if Java process doesn't have rights to save file there.
The Browser.isDisposed() method has been improved. Now it pings Chromium engine to make sure that it's really alive.
The ZoomService.setDefaultZoomLevel(double level) and ZoomService.getDefaultZoomLevel() methods have been added. You can use them to configure default zoom level for all Browser instances in the current context.
The RequestParams.getRequestId() method has been implemented. You can use it to associated HTTP request with its response by ID.
The NetworkDelegate.onDestroyed() method has been added.
The NetworkDelegate.onBeforeSendProxyHeaders() method has been added.
The "--disable-web-security" and "–allow-file-access-from-files" Chromium switchers support has been added. You can use these switchers to disable Same-origin policy in Chromium engine which is enabled by default.
Support of Chromium Geolocation API has been added.
The DOMKeyEvent class has been added.
The DOMMouseEvent class has been added.
The DOMEvent.preventDefault() method has been added.
The DOMEvent.stopPropagation() method has been added.
The BrowserPreferences.setChromiumVariable() method has been implemented. You can use it to configure Chromium engine with required API keys.
The ResourceHandler API has been added. This API allows intercepting all resources that Chromium is trying to load from a web server.
API Changes

New in JxBrowser 4.8 (Dec 27, 2014)

New in JxBrowser 4.7 (Dec 4, 2014)

New in JxBrowser 4.6 (Oct 14, 2014)

New in JxBrowser 4.5 (Aug 7, 2014)

New in JxBrowser 4.4 (May 30, 2014)

New in JxBrowser 4.3.1 (Apr 25, 2014)

New in JxBrowser 4.3 (Mar 22, 2014)

New in JxBrowser 4.2.1 (Feb 13, 2014)

New in JxBrowser 4.2 (Jan 27, 2014)

Upgrade Chromium from 25.0.1364.68 to 31.0.1650.57.
Add Windows Vista support.
Add Windows Server 2003 SP1 support.
Add MacBooks with Retina displays support.
Add the DOMDocument.getElementsByClassName() method.
Add the DOMDocument.getElementsByName() method.
Add the DOMElement.innerHTML() method.
Add StatusListener. See example.
Add the Browser.saveWebPage() method. See example.
Add FTP protocol support. Now you can load FTP URLs.
Add Drag and Drop support. Now you can drag links from loaded web page.
Add Mouse listener. See example.
Add Keyboard listener. See example.
Add Copy, Cut, Paste, Select All shortcuts support on Mac OS X.
Add missing HTML5 video controls.
Add system language support for HTTP headers. By default JxBrowser uses system language in HTTP headers. In previous versions it uses only English.
Improve Flash rendering on Windows.
Improve stability in renderer process on Windows XP SP3.
Improve default popup windows functionality. By default popup windows are not empty anymore.
Fix the issue with pending jxbrowser-chromium.exe processes. Now all jxbrowser-chromium.exe processes will be closed automatically when java.exe process is closed.
Fix the issue when JxBrowser creates unnecessary directories in user’s temp folder.
Fix file encoding dependence issue. Now JxBrowser supports any application file encoding. Previously the file.encoding=UTF-8 VM option should be used.
Fix concurrency issue on Mac OS X. Now JxBrowser doesn’t hang when you load several web pages at the same time on Mac OS X.
Fix unexpected file download interruption. Now the download process isn’t interrupted and continue working even when user disposes Browser instance that initiated file download.
Fix issue when enabled auto detect proxy option overrides JxBrowser Proxy settings.
Fix deadlock on Save File dialog on Mac OS X with JDK 1.7.
Fix issue when it’s impossible to create a Browser instance after killing jxbrowser-chromium.exe processes.
Fix the “IllegalComponentStateException: component must be showing on the screen to determine its location” exception.

New in JxBrowser 4.1 (Nov 25, 2013)

New in JxBrowser 4.0 (Nov 15, 2013)

New in JxBrowser 4.0 Beta (Jul 25, 2013)

New in JxBrowser 3.4 (Apr 24, 2013)

New features:
;Added out-of-process implementation for IE in 64-bit environment. Now each IE Browser instance is running in a separate native process in 64-bit environment.
Added support of print dialog in Mozilla15 and Mozilla engines on Mac OS X.
Added support of the "jexplorer.process.name" System Property.
Added support of the "jxbrowser.ie.dialogs.useAWTThread" System Property.
Added support of the "jxbrowser.plugin.dir" System Property for Mozilla15.
Added support of CardLayout on Mac OS X with JDK 1.7.
Added support of printing functionality on Windows 8 + IE10 for IE engine.
Improvements:
Mozilla15:
Fixed IllegalStateException when disposing Browser instance.
Fixed incorrect Browser location on Mac OS X with JDK 1.7.
Fixed incorrect character encoding in JavaScript-Java bridge.
Fixed native crash when user disposes Browser instance on Mac OS X.
Fixed issue when the Browser.executeScript() method throws exception when JavaScript throws warning message.
Fixed unexpected NoSuchFieldError exception in Java XPCOM bridge.
Fixed unexpected XPCOMException NS_NOINTERFACE in HttpObserver functionality.
Fixed issue when zooming affects context menu location.
Mozilla:
Fixed AbstractMethodError exception when user invokes the Browser.getDocument() method.
Fixed issue when call to the Browser.executeScript() method returns null, but return value is not null on Linux.
Improved focus support for JDK 1.7.
Fixed incorrect character encoding in JavaScript-Java bridge.
Fixed issue when the Browser.executeScript() method throws exception when JavaScript throws warning message.
Internet Explorer engine:
Fixed issue when user cannot create Browser instance using JVM 64-bit.
Fixed issue when user cannot dispose Browser when PDF document is loaded.
Fixed issue when default HTTP Security Policy doesn't work.
Fixed issue when double click on a web page blocks keyboard and mouse events with JDK 1.7.
Fixed focus issue with multiple Browser instances with JVM 64-bit.
Improved focus traversal functionality for JDK 1.7 on a web page with enabled design mode.
Fixed issue when focus traversal functionality doesn't work with JDK 1.7 when window lost focus.
Fixed issue when IE engine doesn't work in modal dialogs.
Fixed crash in JavaScript-Java bridge with JVM 64-bit on Windows 7 + MS IE8.
Improved memory usage in the Browser.toImage() method with JVM 32-bit.
Fixed issue when the Browser.dispose() method ignores result of a confirmation dialog.
Improved memory usage in the Browser.toImage(true) method with JVM 64-bit.
The Browsers.getIEVersion() method now supports IE10 on Windows 8.
Fixed issue when zooming affects context menu location.
Safari:
Fixed issue when TitleListener doesn’t fire events while document title is changed from JavaScript.

New in JxBrowser 3.3 (Dec 14, 2012)

New in JxBrowser 3.2 (Oct 31, 2012)

New features:
Added JDK 1.7 support on Mac OS X for Safari;
Added zoom functionality for Mozilla, Mozilla15 and IE;
Added find text functionality for Mozilla and Mozilla15;
Added ability to set "Display mixed content" security setting for IE;
Added support of Ubuntu 12.04 for Mozilla.
Improvements:
Improved AWT keyboard events dispatching for Mozilla, Mozilla15 and IE. Browser component doesn’t dispatch all keyboard events to Swing anymore;
Improved behavior when child window navigates to a web page with unsupported mime type for Mozilla and Mozilla15;
Improved the Browser.executeScript() method. Added support of script code that contains ‘ and ” symbols;
Added support of DocumentEvent W3C DOM interface for Mozilla and Mozilla15;
Fixed issue when JxBrowser cannot find native libraries in OSGi environment.
Mozilla15 engine:
Improved default behavior of File Download functionality. Now JFileChooser dialog is used to prompt a user instead of automatically saving file to a default directory;
Improved focus functionality. Browser component fires FocusEvent when component gains the focus by clicking on it;
Fixed issue when a user couldn’t select element in HTMLSelectElement on a web page manually using a mouse;
Added support of clipboard keystrokes;
Restored download functionality on Mac OS X in 32-bit mode;
Improved memory usage in DOM functionality.
Mozilla engine:
Added support of Flash plugin on Linux;
Fixed NullPointerException in DefaultNewWindowManager.
IE engine: ¦Added the headers parameter to the IEBrowser.navigate() method;
Added support of the DOMElement.blur() and DOMElement.focus() methods;
Fixed issue when Browser component doesn’t fire ALT key events;
Fixed issue when child window doesn’t receive re-size events;
Fixed issue when Google web page doesn’t receive focus automatically;
Fixed issue when the Browser.setContent() method throws OutOfMemory exception.
Safari engine:
Added support of focus transferring via Tab and Shift+Tab;
Fixed issue when the Browser.executeScript() method crashes JVM.