What's New

From RAD Studio
Jump to: navigation, search

Go Up to Main Page

Go Up to What Was New in Past Releases


The RAD Studio 13.0 Florence release contains the following new and improved features:

Contents

Installation and GetIt Package Manager Enhancements

The following sections detail the Installer and GetIt Package Manager improvements.

Installation Process Updates

Starting in RAD Studio Florence 13.0, the installer no longer automatically installs the Windows SDK. Instead, it checks whether the current version of the SDK is already on the computer and, if not, during the installation, provides the installation link. The download and installation of the Windows SDK are prerequisites for RAD Studio, and we recommend installing it before installing RAD Studio 13.0. Read more details in the Installation Notes.

When installing the Windows SDK, it is recommended to enable the following options:

  • Windows SDK for Desktop C++ x86 Apps
  • Windows SDK for Desktop C++ amd64 Apps

And it will also automatically activate the following:

  • Windows SDK Signing Tools for Desktop Apps
  • Windows SDK for UWP Managed Apps
  • Windows SDK for UWP C++ Apps.

This release removes the ability to install the “Modeling” features from the RAD Studio IDE, both 32-bit and 64-bit versions. Therefore, the feature has been removed from the Feature Manager's additional installation options. This also affects Delphi formatting.

Package Versioning in GetIt Package Manager

Starting RAD Studio Florence 13.0, a single GetIt package can be available in multiple versions, and you can choose to install a specific version, rather than the latest one. When a package has various versions, you can see them in a drop-down menu of the install button.

=link

The package dependencies in the project configuration can now refer to a specific version of a package, allowing for some filtering rules.

Additionally, the GetIt UI now features a general-purpose command button for the main operation, along with a drop-down menu offering additional features: uninstall or update. As well as the ability to export the list of installed packages. Read more in the GetIt Package Manager Window page.

Unified internal version numbers to 37

In this release, RAD Studio unifies all internal version numbers to 37 for RTL, packages, and more, including the following:

  • The main registry entry:
HKEY_CURRENT_USER\SOFTWARE\Embarcadero\BDS\37.0
  • The package version and RTL version.
  • The FMX version: FMX.Types.FireMonkeyVersion
  • The PA Server version.
  • The folder where the product is installed by default:

C:\Program Files (x86)\Embarcadero\Studio\37.0

Note:
In this release, for the IDE installation folder and the runtime packages, this release skips many numbers to move from the current version to 37, while the compiler version is increased by one.

64-bit IDE Improvements

RAD Studio 13.0 includes our first full-featured 64-bit IDE for the Windows 64 target platform. Extending and completing the features and support of the 64-bit IDE initially introduced in RAD Studio version 12.3. Compared to the 64-bit IDE “Initial Release” in 12.3, the 64-bit IDE in 13.0 offers Delphi and C++ support for building and debugging 64-bit Windows applications.

The following are the main updates:

  • Support for Code Templates (Ctrl-J), including the Surround menu.
  • Support for Type libraries, ActiveX, and COM.
  • VA for C++Builder integration in the 64-bit IDE.
  • Implemented a new debugger engine to debug C++ and Delphi Applications.
  • Major improvements in the Delphi debugger performance.
  • Made pointer addresses look more Delphi-style.
  • Removed the Together-based features, including Modeling, Audits, and Metrics.

IDE Changes and Enhancements

This release improves and modernizes the RAD Studio IDE by adding extensive and configurable search features in many IDE panes. The following segment details this and other improvements and changes in the IDE area.

Search Features Improvements

RAD Studio Florence 13.0 introduces specific search features in various panes, enabling faster access to information for large projects, units, and other scenarios. The search experience is unified across all panes that support search, using Ctrl+F. The Esc key closes the search results and returns focus to the original control.

Search features have been added to the sections described below.

  • Structure View: Added an incremental search that supports both designed and source code views, offering syntax highlighting in the source code search results.
  • Project Manager: Added an incremental search that supports high-speed querying and is optimized for large projects (containing 20,000+ files).
  • Message Pane and Events Log: Added an incremental search function that helps navigate large data structures.
  • Object Inspector: Added search icon for quick navigation.
  • Tool Palette: Added search icon for quick navigation.

Also, the new search feature implemented in the Messages and Events searches, but also the Project search and the Structure view search, offer a specific search configuration, available in a drop-down:

=link

Message Log Additions

RAD Studio Florence 13.0 introduces the following new options under IDE > Compiling and Running > Build Log:

  • Enable Highlight in the Compiler Logs.
  • Ask the IDE to group hints and warnings in the Messages pane. This provides greater clarity when navigating a large number of messages, while accelerating the build process.

=link

ToolsAPI Updates

The RAD Studio Florence 13.0 release brings the following updates to the ToolsAPI:

  • Added a new method to update the UI for the Welcome Page.
INTAWelcomePageDataPluginListView370.Invalidate

See more details of the updates mentioned above on the ToolsAPI page.

Smart CodeInsight Improvements

RAD Studio Florence 13.0 introduces a web-based “RAD AI Companion”, a chat and code generator specifically trained on RAD Studio-related content. In the IDE, open Help Menu > RAD AI Companion.

=link

Also, this release added the new Test Connection button in the Smart CodeInsight Options page. Now, users can directly test the configuration without having to try out the chat.

Other improvements include:

  • Models that return “<think>” as part of the response before returning the actual information. In this case, the IDE removes the “thinking” tags.
  • Improved the hints for the buttons in the Smart CodeInsight Chat Window, to show their shortcuts.

Additional IDE Changes

The following sections detail additional updates and enhancements performed in the IDE:

  • Introduced the new IDE option Tabs where users can use the editor background color for editor tabs.
  • Introduced a new IDE option to use the active IDE theme for Structural Highlight colors. Use it to select the color style used for structural highlighting.
  • Enabled the double buffering and any flickering elimination enhancements by default. You can also use the new registry setting (Globals\SingleBufferingInRemoteSessions) to override double buffering.
  • The Refactor menu is grayed out when there is no active refactoring option, rather than showing a “no refactoring” subitem.
  • The IDE exception dialog now directly displays the call stack trace, providing you with crucial information to understand the flow of your code.
  • Added the ability to copy error messages from the structure pane.
  • The Attach to Process dialog box has been redesigned to include additional columns that display information about processes, as well as various UI controls.
  • Improved git source control integration by changing the UI to hint at the fact that you can use GitHub Token Name or Token Key instead of the user name and password.
  • Removed the need to select between HD and 3D form when adding a form to a FireMonkey application. The option to add a 3D form remains available separately.
  • Improved the gutter icons in the Dark Theme mode, avoiding the white border around the images.

IDE Tooling Improvements

RAD Studio includes powerful tools for Delphi and C++ developers to make it easier to write their application code. The following section details improvements and updates to the different IDE Tooling.

DelphiLSP

This release continues the work to improve the DelphiLSP architecture. In response to specific Delphi customer requests, and in the meantime, we are making the old “Classic” Delphi CodeInsight engine for code completion available again. It is available in RAD Studio 13.0 as an alternative to the DelphiLSP-powered version in the IDE, providing access for anyone who wants to use it.

Note:
Enabling the Classic Code Insight Manager affects some features that have been moved to DelphiLSP, such as the Structure Pane, Error Insight, and the editor Navbar (the toolbars at the top of the editor used to navigate code). Those features won’t work if you enable the Classic Code Insight Manager, and we have no plan to revert those changes.

The Classic Code Insight Manager can be enabled in the Tools > Options > Editor > Language > Code Insight tab as shown in the image below:

Delphilsp classic codeInsight.png

Delphi Advisor Wizard Upgrade

RAD Studio 13.0 introduces a new Delphi Upgrade Advisor Wizard, which allows developers to identify meaningful changes to project configuration and code that can significantly improve the compilation time and code tooling experience. The wizard is available as a separate GetIt package. Once installed, it will add a drop-down menu to the IDE.

Besides providing some specific suggestions, the Delphi Upgrade Advisor Wizard comes with reFind scripts you can use to clean up the project's uses statements.

Visual Assist for C++

In RAD Studio Florence 13.0, the VA integration has been improved to better align with how RAD Studio manages toolchains and project configurations.

VA now reloads automatically whenever you change the project configuration, target platform, or toolchain. This ensures that include paths and symbol resolution remain accurate, even when working with multiple projects that use different settings within the same project group. See more information in the Visual Assist for C++ page.

Debugger Updates

This release updates the debugger to LLDB version 20, along with the update to version 20 of the Clang compiler for the Windows 64-bit Modern platform.

The following lists other improvements and quality work performed on the debugger:

For C++:

  • Improved how OutputDebugStringW handles Unicode output.
  • Wide character values that are non-printing are now displayed using the correct format in debugger output.
  • argc and argv now correctly handle arguments with spaces when running under the debugger.

For Delphi:

  • Scoped enumeration values now remain contained adequately within their declared type, avoiding conflicts in the global namespace. Also, these values are now rendered accurately in debugger views.
  • Object member set values are now displayed correctly during debugging.
  • Class variable names are now correctly resolved, with improved name mangling.
  • Unicode variable handling has been improved; the debugger now accepts a broader range of Unicode identifiers.

Also, in the IDE options, you can enable Code Highlight in the Debug Windows.

Resource Compiler

This release made some adjustments to the Resource Compiler integration in RAD Studio.

Starting with Florence 13.0, RAD Studio now distributes an additional open-source resource compiler called resinator. This is now the default in the build system. For more information on the resinator, see GitHub resinator.

Also, added new options to make it easier to pick a different resource compiler, including the classic resource compiler from the Windows SDK.

Updates to the Delphi Compiler

RAD Studio 13.0 offers several improvements to the Delphi language, from a new ternary operator to new compiler directives and more.

If Conditional Operator

The RAD Studio Florence 13.0 release introduces a conditional operator (or ternary operator) to the Object Pascal language. While the behavior is similar to the ?: operator, commonly found in other programming languages, the syntax is more familiar and Pascal-oriented, resembling the if-then-else construct.

See examples and find more information in the Conditional Operators (Delphi) page.

New “is not” and “not in” Operators

The compiler allows “is not” and “not in” operators, which offer a shorter and more readable version of existing combined operators. See an example in the Delphi Expressions page.

New “noreturn” directive

The “noreturn” directive is an attribute that can be associated with procedures, indicating that the call is going to raise an exception and not complete regular execution. This allows the compiler to skip a warning about undefined results and also enables optimization and code elimination. See an example in the Delphi Declarations and Statements page.

This new directive can be used to eliminate the W1035 warnings when exceptions are raised, potentially preventing a proper value from being assigned. See an example in the W1035 Return value of function '%s' might be undefined page.

{$PUSHOPT} and {$POPOPT} Directives

These new Delphi compiler directives save and restore the current set of options and warning configurations.

This release adds the following unbalanced directives warnings.

The same warning will be produced at the end of the source file if there is more $PUSHOPT than $POPOPT in a file. Not all options and settings are eligible for these new directives. See a list of the Eligible Options.

Long directives support for the {$IFOPT} Directive

Starting with RAD Studio Florence 13.0, the {$IFOPT} directive now supports long directives. An example is: 

{$IFOPT SCOPEDENUMS ON}

See the complete list of supported directives in the $IFOPT page.

New constraints for generic type

There are new “interface”, and “unmanaged” constraints for generic types. Unmanaged is a partial replacement of the existing record constraint.

Also, with these new constraints, it is possible to allow L-Value cast for the value type variable declared with a generic type. In a method of a generic class, it is now possible to cast the result of a generic method returning the generic type itself, depending on the concrete type being used.

Example: 

class function TMyData<T>.OperateSubtract(const L, R: T): T;
begin
  if (GetTypeKind(T) = tkInteger) and (SizeOf(T) = 1) then
    Byte(Result) := Byte(L) - Byte(R) // New cast!
  else if (GetTypeKind(T) = tkInteger) and (SizeOf(T) = 2) then
    Word(Result) := Word(L) - Word(R) // New cast!
  // ...
  else if (GetTypeKind(T) = tkFloat) and (SizeOf(T) = 10) then
    Extended(Result) := Extended(L) - Extended(R); // New cast!
end;

NameOf Instrict Function

There is a new NameOf(Identifier) standard procedure, matching the way the similarly named C# function works. You can pass to it any identifier, and it returns the matching string representation: 

 Memo1.Lines.Add (NameOf (Sender));
 Memo1.Lines.Add (NameOf (self));
 Memo1.Lines.Add (NameOf (TForm31));
 Memo1.Lines.Add (NameOf (X));
 Memo1.Lines.Add (NameOf (Integer));

Implicit “Self” parameter declaration in record class operators Initialize and Finalize

The two class operators for custom-managed records allow for a much more concise declaration syntax, skipping the self parameter (which remains implicitly available). This implies no change in behavior and generated code, only the syntax is simplified.

See an example in the Custom Managed Records page.

Additional Delphi Compiler Improvements

The following section lists additional Delphi compiler improvements and quality enhancements.

  • The $WEAKPACKAGEUNIT directive now reports an error () if the unit contains any global variables in the interface sections, any initialization or finalization blocks, and any class constructor or destructor.
Note:
This change can prevent existing code from compiling.
  • The compiler error ‘E2033’ (Types of actual and formal var parameters must be identical), now includes the names of the types involved.
  • Added two new warnings, W1076 and W1077, for data casting.

C++Win64 Modern Platform Updated to Clang 20

The RAD Studio Florence 13.0 release updates the Modern Win64 C++ compiler from Clang 15 (the version shipped in 12.x) to Clang version 20. The new Clang-based compiler introduces C++23 support. Also, this release updates all of the other elements of the Modern Win64 C++ toolchain.

This release brings significant enhancements focused on modern C++ standards, compatibility, and stability. Below are the key improvements included in this release:

  • LLVM Toolchain Upgrade (v20): The toolchain has been upgraded from LLVM v15 to LLVM v20. This update supports recent C++ standards and compiler optimizations.
  • Improved ASAN Support: The AddressSanitizer (ASAN) runtime is now fixed for compatibility with Windows 11.
  • New C++ Standard Option: BCC64X now defaults to C++23, but users can choose to target C++20 or C++17 as needed.
  • Versioned RTL/STL Shared Libraries: Shared runtime libraries (e.g., libc++.dll) are now suffixed with the BDS version number (e.g., libc++-370.dll). This prevents runtime conflicts when multiple versions of RAD Studio are installed.
  • Resolved Legacy Issues: Numerous bugs and inconsistencies present in LLVM v15 and previous toolchain versions have been addressed in this release.

Delphi RTL Improvements

This release improves the JSON RTL so that one can suppress a field when it has a particular value by adding a new attribute. See other JSON-related improvements as well as more Delphi RTL updates below.

SmartCore AI Component Pack

RAD Studio 13.0 introduces a new set of core AI components designed to help customers add AI features to their apps or build brand new AI-focused apps with Delphi or C++Builder. This is a building block and a foundation for the future: It’s a core architecture our customers and 3rd party vendors can build on and extend to integrate with additional AI engines and UI controls.

The SmartCore AI Component Pack is available in GetIt. Use the new AI connection component with a role similar to that of a database connection in FireDAC. This single AI-engine agnostic component will use specific drivers to communicate via REST with different AI engines (including OpenAI, Claude, Gemini, and Ollama). The SmartCore AI engine offers the ability to add additional drivers for AI providers to expand the capabilities of your project as the market develops. The configuration is managed via an easy-to-use AI connection wizard.

Part of the component pack is a set of AI request components for different data types (like text, images, and structured data), which can be associated with prompts and can be bound directly with UI controls to display the results. This component-based model makes it very simple to use the SmartCore AI Components in RAD Studio 13.0.

JSON Processing

This section lists JSON-related updates:

  • Added the TJsonOption joIgnoreDefault and joIgnoreSpecial attributes.
  • TMarshalUnmarshalBase.ValueSerialization: TJsonValueSerialization with jvExcludeSpecial default.
  • TJSONValue.GetValue<T>(const APath: string; ADefaultValue: T): T behavior is changed: It finds a JSON value if possible. If found, the JSON value is converted to a specified type. If not found, or if it cannot be restored, or if the JSON value is null, then it returns a default value.
  • The TJSONNumber class is now inherited directly from the TJSONValue class.
  • The TJSONString class is marked as "sealed".
  • TJsonReader now has ReadAsUInt64.

The JSON Serializer offers the option to skip properties with default values:

  • New TJsonConverter.CanWrite(AValue) overloaded method.
  • There is a TJsonSerializer.MemberSerialization: TJsonMemberSerialization property with TJsonMemberSerialization.Fields as default.

Other Delphi RTL Changes

The following section shows other Delphi RTL updates for the RAD Studio Florence 13.0 release.

  • Refreshed the WinRT APIs, the external snapshot of WinAPI headers from the WinMD definition (in GetIt), and cleaned up WinAPI declarations in the RTL files.
  • Updated the integrated version of DUnitX to version 0.4.1 (last modified on June 26, 2025).
  • Added a case-insensitive version of the TStringHelper.Contains function.
  • Added the System.StrUtils.LiteralToInt unit of functions that supports "_" and "%binary nums". As a consequence, TIntegerProperty and TInt64Property classes now use TryLiteralToInt.
  • Added new TPath.Exists.
  • Added ReadUInt64 and WriteUInt64 to the TRegistry class.
  • TThreadedQueue now has a Count property for naming consistency.
  • Updated TDictionary<K,V> and TOrderedDictionary<K,V>. Casting TOrderedDictionary to TDictionary preserves TOrderedDictionary behavior.
  • The constructors for synchronization classes TMutex, TSemaphore, and TEvent now set the THandleObject.LastError property before returning to the caller.
  • There is a TStringList constructor with the signature:
constructor Create(Options: TStringsOptions; Duplicates: TDuplicates = dupIgnore); overload;
  • The System.RTTI unit has a new GetStorageSize function to read the number of bytes required to store a value of that type in memory.
  • Added a new TSizeF.Zero method.
  • For debugging deadlock scenarios, we added the WriterID property to IReadWrite/TMultiReadExclusiveWriteSync.
  • Restructured TRttiDataMember by introducing a new intermediate class:
    • TRttiPlaceMember
    • TRttiDataMember
    • TRttiIndexedProperty

VCL Enhancements

In 13.0, RAD Studio introduces new features and extensive quality improvements for the powerful integrated UI libraries. VCL includes an integration of the UIAutomation Microsoft interfaces, TitleBar styling, and more.

UIAutomation Support

To improve the accessibility and integration of VCL applications with UI testing tools, version 13.0 adds support for UIAutomation to the VCL library.

TitleBar Improvements

In this release, the TitleBarPanel supports custom VCL styles. This adds support for drawing styled controls in the title bar area.

In addition, this release brings the following updates:

  • Added a new TTitleBar.StyleColors property to enable automatic use of the VCL Styles colors for background and buttons on the title bar. The support includes using the following controls: TButton, TSpeedButton, TCheckBox, TRadioButton, TToolBar, TEdit, TComboBox, TFormTabsBar, TActionToolBar, and TActionMainMenuBar.
  • Improvement in the use of the TitleBar in MDI applications.
  • Added support for Hint for customers buttons on the TitleBar.
  • HighDPI support improvements.

ControlList Improvements

RAD Studio Florence 13.0 offers the following improvements to the ControlList component:

  • The ControlList component supports a new type of hosted control, the SplitButton. This implementation comes with the following:
    • The clbkSplitPushButton and clbkSplitToolButton styles for the TControlListButton control.
    • A new look for a button split drop-down area with an arrow.
    • DropDownMenu property for TControlListButton control.
  • Added a new OnGetItemHint event and a new ShowItemHint property to offer per-item hints, rather than global control hints.

Enhancements to the FormsTabsBar component

RAD Studio Florence 13.0 offers the following improvements to the FormsTabBar component, introduced in RAD Studio 12:

  • Added transparency support with two new properties: Transparent and ShowBottomLine.
  • Added a new OnGetTabCaption event that makes the TFormTabsBar more flexible.
  • The TabFromPoint and TabIndexFromPoint methods are now public.
  • Added a new MouseMiddleButtonClose property to close a tab with the middle mouse button.

EdgeBrowser Updates

This release updates the interfaces to the Microsoft WebView 2 control (aka Chromium-based Edge) to version 1.0.3296.44 of the WebView2 SDK.

Also, updates the TEdgeBrowser component (and the matching demo) to support AddWebResourceRequestedFilterWithRequestSourceKinds instead of AddWebResourceRequestedFilter.

WinUI 3 Demo

This release refreshes the WinUI 3 headers and the standalone WinUI 3 demo, previously available as a separate download from GetIt, and is now integrated into the core product demos.

ActionMainMenuBar Scrolling

This release adds a new scrolling feature for the TActionMainMenuBar control, which is enabled when the vertical height exceeds the screen height.

See an example of this feature in action below. Notice that this is also potentially used by the RAD Studio IDE, in case it’s executed on a low-resolution screen.

=link

Other VCL Improvements

The following are additional updates and changes in VCL.

  • Removed leftover Win98-specific support from VCL code.
  • Improved the TToggleSwitch control to make it look like a Windows 10 / Windows 11 toggle switch, updating the “Windows 10“ family of VCL styles.
  • Updated the TDragDockObject class to make the DropAlign property read/write.
  • Added a new TActionMainMenuBar.OnSelectMenuItem event to help show hints for menu items in the ActionMainMenuBar.
  • For the TCategoryButtons control, added Visible and Enabled properties of TButtonItem and TButtonCategory.
  • New TStyleManager.FormBorderSize property.
  • New TMonthCalendar.OnChange event.
  • New OnBeforeResize and OnAfterResize events added for TSplitter.
  • Added a new public function, VCLEditors.GetFormDPIForVCLEditors, to help with the development of VCL editors under HiDPI IDE.
  • TCanvas offers new overloaded methods with TPoint parameters for the following methods: AngleArc, Draw, LineTo, MoveTo, FloodFill, and TextOut.

FireMonkey Updates

FireMonkey in RAD Studio 13.0 integrates a new Display Link Service offering highly improved stability and smoothness of animations. The framework also offers increased performance when copying bitmaps by leveraging the GPU, a brand new MaskEdit component, and more.

This section lists updates and enhancements done to the FireMonkey area.

Apple Platform APIs

The RAD Studio Florence 13.0 release offers a significant update and expansion of the iOS and macOS platform APIs available in Delphi header files. This release also updates all iOS API headers from RTL to iOS 18.4, specific extensions include:

Android Platform APIs

RAD Studio Florence 13.0 targets Android API level 35 by default, and includes tooling to support newer API levels in the future.

The following are some additional changes:

  • Enhanced the TTexture class to support the GL_TEXTURE_EXTERNAL_OES target.
  • Reworked the Java2OP command-line tool, replacing Doclava with the new jparser command-line tool. This eliminates issues related to reimplementing APIs declared in packages exported by platform modules.
  • Added getEventTimeNanos and getHistoricalEventTimeNanos to JMotionEvent in Androidapi.JNI.GraphicsContentViewText.pas.
  • Updated the manifestmerger command-line tool to version 31.10.1.
  • Updated the AAPT2 command-line tool to version 8.10.1.
  • Updated dexter command line utility to version 1.0.1.
  • Updated rclasser command line utility to version 1.0.1.
  • Updated bundletool command line utility to version 1.18.1.
  • Updated packager command line utility to version 1.2.1.

MaskEdit Control

RAD Studio Florence 13.0 introduces a new MaskEdit control for FireMonkey that includes a specific designer for input masks.

=link

Unlike the VCL counterpart, in the FMX TMaskEdit implementation, an exception is not raised if the current value in the MaskEdit is not valid. Instead, it is recommended to use the OnValidateError event. This event allows the developer to provide any visual feedback to the user about an invalid value. If the value is still incorrect after the focus reset, it remains in the invalid state, and the OnChange event is not triggered until the value becomes valid.

New Display Link Service

The new Display Link Service for FMX is now the central engine for all application animations, entirely replacing the legacy timer-based engine previously used.

This frame-accurate system leverages the display’s actual refresh rate to synchronize and drive all UI updates and animations. By utilizing platform-native APIs such as JChoreographer (Android) and CADisplayLink (iOS), the service ensures that animation processing is tightly aligned with VSync events, resulting in smoother and more consistent visuals across all platforms.

Note:
Notice that this fundamental and structural change implies some changes and incompatibilities with existing code. For example, the Interval property in TAniCalculations has been removed[1], while some other properties were modified from TDateTime to Double.

FMX Linux

For the RAD Studio Florence 13.0 release, a new version of FMX Linux is available in the GetIt packages. Also, the IDE integration of the library is now smoother.

Skia Updates

RAD Studio Florence 13.0 release includes an update of the Skia Library integration (Skia4Delphi) to the latest version 7.0.0. This update addresses several issues and offers improvements to the Skia integration.

See Releases - skia4delphi/skia4delphi

Additional FireMonkey Controls and Components Improvements

The following are additional updates and changes in FireMonkey Controls and Components.

  • The TComboEdit component now supports typing autocomplete with an editable text configuration.
  • Added a new set of properties to the TPresentedScrollBox for the user to control scroll animations, bounces, and touch interactions. The following are the new properties: AutoHide, Bounces, ScrollAnimation, ScrollDirections, and TouchTracking.
  • Added the new component TApplicationEvents.
  • Changed TDateTime to Double since the API now works with intervals measured in seconds. iOS’s DisplayLink works with seconds, while Android’s JChoreographer works with nanoseconds.
  • Converted methods of FMX.Text.TextEditor and FMX.Text.SpellingManager to be virtual.
  • Redesigned the IFMXSpellCheckerService by creating the new interface IFMXSpellCheckerServiceEx, which allows working with different languages and sentences.
  • Published the HitTest property for the TGlyph component.
  • Added a TextPrompt property to TMemo, used for placeholder text when the control’s text is empty. Works like the TEdit counterpart.
  • Added a new OnCheckedChange event for TListBoxItem.
  • Added orientation for “grip” in TSplitter style.
  • Published the property of TouchTargetExpansion for TShape and other visual controls.
  • TBindNavigator button icons can now be modified via styles.
  • Added a new TTrackBar Reverse property, which allows the reverse of the trackbar. In addition, TTrackBar now supports mouse wheel scrolling.
  • MenuItem height used to be a constant. Now, the user can add a TStyleTag object with StyleName=“height“ to the TMenuItem style and specify the menu item height in the Value property.
  • TGlyph has new properties, ImageRect and Bitmap, that allow for real drawing size and coordinates.
  • The FContentHeight value of the TExpander is now accessible in the ContentHeight property.
  • Improved TStringGrid TPopupColumn input.
  • Introduced DoStateChanged virtual methods for TRadioButton, TCheckBox, and TArcDial.
  • There is a new class property Helper of type TCanvasHelper in TCustomCanvasGpu, meant for developers interested in extending the FMX library.
  • The FMX.TListBoxGroupHeader now has TextSetting.Trimming.
  • Added the AutoTranslate property to TMainMenu and TPopupMenu.
  • Added an overloaded version of the method EvaluateJavaScript to TWebBrowser, with a TJavaScriptResultCallback parameter.
  • Added a new component, TApplicationEvents, similar to the VCL counterpart.
  • Update TAlignLayout to Include New Alignment Options for Centering Controls. New alignment methods include: TopCenter, TopLeft, TopRight, LeftCenter, LeftTop, LeftBottom, RightCenter, RightTop, RightBottom, BottomCenter, BottomLeft, and BottomRight.
  • Added support for the 16.0 version of Emoji symbols.
  • TBindNavigator now offers the option to configure specific Hints and Styles for each button, using the subproperties of the ButtonsOptions property.

Other Mobile Improvements

  • Fullscreen support for iOS.
  • RAD Studio now passes iOS startup parameters, which can be used for interaction with other frameworks and apps (see TApplicationEvent; FinishedLaunching).
  • Solved issue with dictation on iOS.
  • Added the ability to disable the bounce in a list view on iOS, using the new property TListView.Bounces. This property allows a developer to control the ability to scroll the content beyond its boundaries. It affects only the touch screen.

Database and FireDAC

From the expanded support for Unsigned Big Integer database fields to more flexible options when dragging a field from the fields editor to a visual form, there are a large number of improvements in this area.

This section lists updates and enhancements done to the Database and FireDAC components.

DataBase RTL

This section lists updates and enhancements made to the DataBase RTL:

  • Added a new field type to TFieldType to support Unsigned Big Integer. There is now a TFieldType.ftLargeUint type. FireDAC supports it through Oracle and MySQL drivers, as well as the TFDMemTable.
  • Added a new EllipsisPosition property to the VCL TDBText component, working in the same way as with TLabel.
  • Added new DataSet properties to access the attached DataSource objects:
  • Added an overloaded DrpCtrls.RegisterFieldControl procedure that allows a custom setup of the created custom dataware control, see the example below:
uses DrpCtrls;
  RegisterFieldControl(TIntegerField, 'TDBLabeledEdit',
    procedure (Control: TControl; DataSource: TDataSource; Field: TField)
    var
      LEdit: TDBLabeledEdit;
    begin
      LEdit := Control as TDBLabeledEdit;
      LEdit.DataSource := DataSource;
      LEdit.DataField := Field.FullName;
      LEdit.EditLabel.Caption := Field.DisplayLabel;
    end);

FireDAC

This release adds the following updates and enhancements in FireDAC:

  • Added support for parallel operation in TFDFBBackup for Firebird 5.0+. ParallelWorkers (TFDIBBackup, TFDIBRestore, and TFDIBValidate) specifies the number of parallel workers used by a service manager to execute requested jobs.
  • TFDMemTable supports RecsSkip and RecsMax. The RecsSkip and RecsMax settings are applied when the Filter property is set to True.
  • Added flexibility to FireDAC when returning textual data for PostgreSQL array types. The following are the two ways to show relacl fields as a readable text:
    • to cast a field - relacl::TEXT
    • to set ResourceOptions.DirectExecute to True. Then, FireDAC internally will use PostgreSQL's textual format for result sets.
  • Converted some transaction-related methods in the TFDCustomConnection and TFDCustomTransaction classes into virtual methods to help customize the behavior of derived classes.
  • TFDMemTable allows loading standard JSON (not generated by saving data from FireDAC) using the new TFDStorageFormat.sfFreeFormJSON.
    Examples:
FDMemTable1.LoadFromFile('test.json', sfFreeFormJSON);
FDMemTable1.SaveToFile('test2.json', sfFreeFormJSON).
  • For Oracle connections, RAD Studio Florence 13.0 adds support for OAuth 2.0 authentication within the FireDAC TFDConnection component in Delphi.
    • New connection definition parameters:
      • OAuth_Token - specifies an OAuth2 or IAM token. Requires Oracle 19.13.
      • OAuth_PrivKey - specifies IAM PoP private key. When specified, then IAM token-based authentication is used; otherwise, Azure OAuth2 authentication is used. Requires Oracle 19.13.
    • Use the TOAuth2Authenticator component to get an OAuth2 token. Use FireDAC Automatic Connection Recovery to renew and submit a new token.

DataSnap

This release adds certificate validation events to TFDConnection and TDSClientCallbackChannelManager, which can use HTTPS as transport:

Updates to the Web Client Libraries

The RAD Studio Florence 13.0 release brings the following updates:

WebBroker Updates

The RAD Studio 13.0 Florence release offers several extensions to WebBroker, including a modern, integrated HTTP session management, improved Apache integration, Nginx web server support, enhanced logging, and easy WebStencils integration, making web applications both simpler to develop and more powerful.

Session Management and Authentication

This release introduces a new class, TWebSessionManager, which manages a list of TWebSession objects. It is a non-visual component that offers a set of properties at design time.

The TWebRequest.Session property returns the session of the request. Store custom objects in TWebSession.DataVars are now made directly available in WebStencils scripts.

Session authentication can be integrated with session management and can be based on different logic.

A “sentinel” algorithm is built into TCustomWebDispatcher.DispatchAction, and delegates processing to IWebSessionManager or IWebAuthenticator.

More changes to the library support are mentioned below:

  • Session Management:
    • Added the TWebSessionManager that manages a collection of TWebSession objects. It is a non-visual component with design-time properties with the following configurations: IdLocation, IdName, Scope (ssUnlimited, ssUser, and ssUserAndIP), Timeout, and SharedSecret.
    • Added the TWebSession, which represents individual sessions.
  • Authentication:
    • Added the TWebBasicAutenticator, which implements HTTP Basic Authentication.
    • Added the TWebFormsAuthenticator, which implements HTML-form-based authentication.
  • Authorization:
    • TWebAuthorizer provides role-based access control through authorization zones.
    • Authorization checks user roles against zone requirements. Use the OnAuthorize event for custom authorization logic. Failed authorization redirects to UnauthorizedURL or returns 403 status.
  • WebStencils Integration:
    • Sessions integrate with the following WebStencils templating:
      • @session.xxx: Access session object properties.
      • @session.DataVars: Access session custom variables.
      • @session.UserHasRole(<string>): Checks if a user has a specific role.
      • @<n>: Direct access to objects stored in DataVars with key <n>.
  • New Request Properties:
    • TWebRequest.AuthUserName: Authenticated user name.
    • TWebRequest.AuthMethod: Authentication method used.
    • TWebRequest.Session: Current request session object.

To use these components, add them to the web module (only one TWebSessionManager and one authenticator per module), and the components are automatically detected by the dispatcher sentinel. The processing flow is Session Management > Authentication > Authorization > Action Dispatch.

Sessions are automatically created when TWebSessionManager is present. Authentication is mandatory when an authenticator component is added (use TWebAuthorizer to control this). All components work together through interfaces (IWebSessionManager, IWebAuthenticator, IWebAuthorizer).

Log output

There is a new TWebApplication.Log method with severity, message, and params, that is supported on all platforms, using the proper hosting web server log system:

  • Apache: Apache server log file, by default logs\error.log.
  • ISAPI: Windows Event Log (eventvwr.msc): Windows Logs
  • CGI: file with TCGIApplication.LogFileName name.
  • FastCGI: HTTP (Apache, nginx) server log file, by default logs\error.log.

Extended TWebRequest

This release extended the TWebRequest to now offer:

  • ExtractAllHeaders method, AllHeaders property
  • SessionID
  • AuthUserName and AuthMethod

Apache Config

This release introduces Apache Config, a textual and extensible configuration system. Below is an example of the configuration.

Example: 

MyEnabled On
MyFolder "c:/temp"
MyMimeTypes image/bmp text/html
<Location /qwe/asd>
  MyEnabled On
  MyFolder "c:/temp/asd"
</Location>
<Location /qwe/asd/zxc>
  MyMimeTypes image/png image/jpeg text/html
  MyRole admin
</Location>

Uses mapping of a Delphi record to Apache directives (only non-managed field types, including string[n]):

  • Use WebHTTPMethod attributes to customize mapping.
  • Use the Web.ApacheApp.InitConfig to register the record type. Call it right after InitApplication.
  • Use the Web.ApacheHTTP. TApacheRequest.GetConfig to get a record instance with values specific to a request URL.
  • Use the Web.HTTPDMethods.IHTTPDConfigAdaptor, THTTPDCustomConfigAdaptor<T> to customize record initialization and overriding.

The WebBroker Wizard has the option to include an Apache config sample.

Attention:
This feature is not supported in C++ Builder.


FastGCI and NGINX Support

This release adds FastCGI support for nginx. This interface provides access to a web module running as a separate application.

In more detail:

  • Added a new Web.FastCGIApp.pas, Web.FastCGIHTTP.pas, and Web.FCGI_Protocol.pas units.
  • FastCGI is supported by nginx and Apache.
  • Added new classes: TFastCGIApplication, TFastCGIRequest, and TFastCGIResponse.
  • Added support for FastCGI to the WebBroker Wizard.

To register an application with nginx, add the following lines to conf\nginx.conf: 

# 1) "location" mask, fastcgi_param directives are environment dependent
# 2) Update the fastcgi_pass directive when the host or port is different
# 3) This will redirect the request "GET http://localhost:8000/fcgi/" 
#    to the FastCGI server.

        location ~ ^/fcgi(.*)$ {
            include fastcgi_params;

            fastcgi_param SCRIPT_NAME /fcgi;
            fastcgi_param PATH_INFO   $1;
            fastcgi_param SCRIPT_FILENAME dummy;
            fastcgi_param PATH_TRANSLATED $document_root$1;
            fastcgi_keep_conn on;

            fastcgi_pass 127.0.0.1:9000;
        }

WebStencils Enhancements

WebStencils significantly extends the existing web technologies in RAD Studio by providing server-side scripting and turning RAD Server from a Web Service engine into a Web Site and Web Service tool.

The following section describes the WebStencils updates introduced in RAD Studio Florence 13.0.

  • Implemented the whitelist mechanism property to prevent exposure of sensitive information like database connection strings or any other sensitive information. Find out how to customize the whitelist.
  • Introduced the ability to add extra variables to the script engine outside of the object and dataset models.
  • The WebStencils @ notation for a dataset now allows access to the dataset properties, in addition to the field. The level of access to the show field can be controlled using a specific property (TWebStencilsProcessor.Whitelist) to prevent unauthorized access to internal information. Find out more here.
  • WebStencils now automatically integrates with web sessions when available, learn more here.
  • WebStencils now supports @ExtraHeader content propagation through nested layout hierarchies, learn more here.
  • Added enhancements to the WebStencils Keywords by giving the keyword @page two extra values, such as @page.request_path and @page.request_segment.

RAD Server Improvements

RAD Studio 13.0 makes the use of the Swagger-based API Documentation more flexible, adds to the RAD Server Multi-tenancy support an option to integrate tenant-specific configuration, and introduces a simple and direct way to implement API Versioning.

The following section points out the improvements to RAD Server in the RAD Studio Florence 13.0 release.

  • RAD Server Swagger API Documentation; Schema and reference params for Swagger and OpenAPI definitions are now optional.
  • Adds the option to return a custom header in the Swagger response doc using the new EndPointResponseHeaderAttribute attribute.
  • This release adds to the RAD Server Multi-Tenancy Support a way to integrate tenant-specific configuration (like database connections), to be set up before any business logic runs. Specifically, the following were added:
    • Tenant-prefixed server variables: specifying a tenant-prefixed variable ensures that its value is used. Otherwise, a variable without a tenant prefix is used.
    • An IEMSResourceInterceptor interface with BeforeRequest and AfterRequest methods.
  • RAD Server now supports exporting multiple versions of the same API function, allowing clients to invoke the REST API in its most recent version or an older one by using the new ResourceVersion attribute. The new TEMSVersionStatus values are as follows:
    • Experimental - uses ver/myapi/… as base url and adds “Experimental” to the Swagger description.
    • Active - uses ver/myapi/… as base url.
    • Default - uses ver/myapi/… and myapi/… as base urls.
    • Deprecated - uses ver/myapi/… as base url and adds “Deprecated” to the Swagger description.

See Also

References

  1. ↑ The reason for removing the animation render interval lies in the fact that it now consistently matches the current refresh rate of the display. The application can run on devices with 60 Hz, 90 Hz, or 120 Hz displays, and scrolling will automatically become smoother, without the need for manual interval adjustments. The animations that are running will constantly be updated (recalculated) on each new frame of the screen.
Retrieved from "https://docwiki.embarcadero.com/RADStudio/Florence/e/index.php?title=What%27s_New&oldid=279062"