What's New in Qt 6.4

• Added https:// as an alias for https://. This is now the recommended name for referring to a Latin-1 string view.

• The QLatin1StringView(const char *, qsizetype) and QLatin1StringView(const char *, const char *) constructors are made non-explicit.

• Added literal operator _L1 for creating Latin-1 string and char literals in the https:// namespace.

• Added literal operators _s and _ba for creating https:// and https:// literals respectively, in the https:// namespace. Deprecated _qs and _qba in favor of _s and _ba.

• Deprecated QString::count() and QByteArray::count() that take no parameters, to avoid confusion with the algorithm overloads of the same name. They can be replaced by size() or length() methods.

• https:// and https:// support now all codecs supported by ICU when Qt is built with ICU support enabled.

• In the classes for Android and JNI development, https:// and https://, overloads have been added for callMethod, https:// and similar methods. It is now possible to call Java functions and register native methods without specifying a signature string.

• The new template function QJniObject::construct() allows instantiating of a Java class from C++ without specifying a type or signature string.

• https:// now has a percentDecoded() instance method as an alternative to calling the fromPercentEncoding() static method on the instance.

• https:// now supports input and output of char16_t.

• https:// now has a localeAwareCompare() method and can count() how many times a given sub-string appears.

• https:// can now be constructed from various std::chrono year-month-day structure types, when available, and it has an addDuration() taking a std::chrono::days, when available.

• https:// likewise gains an addDuration(std::chrono::milliseconds), along with arithmetic to add or subtract the same type, a difference of https:// values returning it, and a few static pseudo-constructors taking various std::chrono types describing a moment in time.

• Added https://(const std::chrono::time_zone *).

• https://'s construction by name now accepts https://.

• Added https://(), https://(), and https://().

• Several new properties and functions has been added to https:// that improves support for keyboard navigation and selection, row- and column selections, animations, sub-cell positioning, and more.

• https:// now support selections, and has gained a broader API for expanding and collapsing nodes in the tree recursively.

• https:// is now functional with all supported 3D graphics APIs (Vulkan, Metal, Direct3D 11) in addition to OpenGL. Applications no longer have to enforce rendering with OpenGL when using https://.

• Added support for arrays of combined image samplers in shaders used with custom materials. This is supported by the new function https://() and the enhanced semantics of the existing texture argument of https://().

• Added support changing the polygon rasterization mode from solid to line in https://. (available only when the 3D API in use supports this)

• https:// and https:// were not useful in previous Qt 6 releases, with the legacy values ignored in practice. This is now documented and new, actually useful values are introduced, in particular to enable requesting floating point (FP16 or FP32) textures instead of RGBA8, if desired.

• Added https://(), enabling redirecting the output from a https:// using the software backend as well.

• Added overloads in https:// that enable specifying the native format of the texture or image object. This is relevant in some advanced use cases when one has to work with native textures that are not RGBA8. Note that only native formats that are supported by Qt's rendering infrastructure are accepted.

• Added https://() to https://, which allows requesting the Qt Quick renderer to alter its matrices to get vertically flipped results when redirecting the 3D API-based rendering into a texture.

• Qt Quick windows will now attempt to use the software rasterization platform of Direct 3D (WARP) in case the primary graphics device is not compatible with Qt, without having to resort to manually setting environment variables.

• Added simple heuristics to the threaded render loop of the Qt Quick scenegraph for recognizing broken vsync-based throttling. When frames are rendered/presented too fast, without blocking the render thread, it now switches automatically to the regular timer-based approach of running animations, thus preventing QML animations running too fast.

• Added https:// for custom animations. Allows running custom scripts in synchronization with the animation frames.

• Added a new native-looking style for iOS, https://, as Tech Preview.

• https:// has three new properties that describes if it's current, selected, or highlighted in the https://.

• Added https://. This is a native dialog on platforms that support it, and a non-native Qt Quick dialog on other platforms.

  The non-native dialog supports all of the non-native styles: Basic, Fusion, Imagine, Material and Universal.

• https:// has new https://() and https://() member functions, with overloads that allow hiding and showing rows by index, input widget, or row layout.

• https:// has a new https:// property. Use it to control whether the widget shows a clear button that allows the user to clear the edit.

• https:// has a new slot, https://, that allows applications to move to a page without visiting the pages between the current page and the target.

• Added https://. This simplifies creation of a server which solely communicates over TLS.

• https:// now has loadBackendByFeatures(Features) and loadBackendByName(https://), meant to eventually replace the corresponding overloaded load(Features/https://) functions which are now marked as deprecated.

• QTestEventLoop::enterLoopMSecs() now uses a PreciseTimer if the timeout is less than a second.

• Custom QTest::compare() implementations should now revise any calls to QTest::compare_helper() to use one of the two new overloads instead of the old one, which is now deprecated (so as to only generate the strings to represent values in a failure report if the check actually does fail).

• Added https://().

• New macros QCOMPARE_{EQ,NE,GT,GE,LT,LE}() support comparisons with reporting similar to that of https://(). The EQ one does exact comparisons, without https://()'s customizations. These also come with the usual QTRY_COMPARE_*() and QTRY_COMPARE_*_WITH_TIMEOUT() variants.

• QML Language

  • You can register custom value types with names now. That is, the argument to https:// is no longer ignored. It must be lower case. Once registered, you can declare properties of your own value types in QML.

  • You can store any named value type in a list in QML now. For example list<rect> in QML is like a https://<https://> in C++. This removes the need to use var for such properties or wrap their elements into objects.

  • The new pragma ComponentBehavior lets you specify whether components defined in a QML file can be used outside of their creation context. If not (pragma ComponentBehavior: Bound), then Qt Quick Compiler can optimize your code better.

• QML Type Compiler (qmltc)

  • Expanded QML language coverage

• QML Script Compiler (qmlsc, qmlcachegen)

  • Various operations on lists of value types are now compiled to C++.

  • Dead code and dead stores are optimized out more aggressively now.

  • Type conversions now happen at the place where a value is written, not at the place where it's read. If the value is read multiple times, this is faster.

• QML Linter (qmllint)

  • Added new warnings regarding proper use of https:// and https://.Controls

• QML Language Server (qmlls)

  • Added completions support

  • Added code action fixing for some linter warnings/hints

  • Moved executable to libexec

• Cleaned up CMake API:

  • https:// used to invoke the QML type compiler is deprecated. Its functionality has been integrated into https://

• Added a preview of lightmap baking support. This provides a static global illumination solution with lightmaps pre-generated using raytracing. See https:// for details.

• Added https:// to enable using the specular/glossiness workflow instead of metalness/roughness.

• Added the https:// type that allows creating line shaped sprite particles.

• Added the https:// property to control if a model is rendered by reflection probes and if it can be seen in reflections. The same property is also introduced for https://.

• Added the https:// property to move the box relative to the position of the probe without affecting the position of the capture point.

• Added the https:// property to display a cube visualizing the probe box.

• Added https:// to enable creating a height-field geometry from an image file.

• Added https:// to enable custom materials and post-processing effects to work with cube map textures in the shaders. The input is either a .ktx container with image data for all 6 faces, or 6 individual image files.

• Added support for rendering a skybox from a cubemap instead of the light probe. This can be requested by setting the background mode https://.

• Added https:// to procedurally generate a HDR light probe or sky box texture.

• Improved shadow rendering for point and spot lights.

• Added the https:// property to https:// to allow specifying the backing texture format when the https:// is using its (default) Offscreen render mode. The available values are the same as with https:// (which itself is also revised in 6.4). This enables using floating point textures instead of the default RGBA8.

• Support for importing UIP files was removed. The mapping from old Qt 3D Studio features to Qt Quick 3D was problematic in previous releases already. Therefore, Qt 6.4 removes support for .uip files from the balsam tool.

• https:// is no longer exported. This class inherits https:// publicly, but https:// isn't designed to be inherited by an exported class.

  This is not backward compatible, but this will prevent future BC breaks going forward.

• In Qt Bluetooth various error enums are extended with new error codes that represent a missing permissions error. Currently these codes are used on Android and macOS/iOS. See https:// as an example.

• HTML5 file-system access API added, controlled by https://

• https:// improved error codes, in particular for HTTP errors

• https://() now works on pages already loaded

• QWebEngineSettings::NavigateOnDrop added to allow disabling navigation on drag-an-drop of URLs

• https:// added to allow interception of websocket connections

Qt is now fully supported on the WebAssembly platform. See the platform documentation at https:// for details.

Android▲

Boot to Qt▲

QNX▲

WebOS▲