What's New in Delphi and C++Builder XE6

From RAD Studio
Jump to: navigation, search

Go Up to What's New

XE6 is a "quality release". That is, we have fixed hundreds of design and performance bugs for XE6. These fixes will significantly improve the user experience with RAD Studio.

★ C++Builder Supports Application Development for the Android Platform

Creating C++ FireMonkey Apps for Android


New C++ Compiler for the Android Target Platform

BCCAARM.EXE, the C++ Compiler for Android supports development for the Android target platform.

Automatic Reference Counting (ARC) Is Enabled for BCCAARM

  • BCCAARM uses automatic reference counting (ARC) for C++ Android in order to be compatible with Delphi Android.
    All the ARC management is handled inside the BCCAARM compiler, so you should not need to do anything different in order to work in the C++ Android ARC environment. Your code can still use pointer syntax for a Delphi class instance. The BCCAARM compiler treats these pointers as special pointers, and thus neither declarations nor usage have to change.
  • For more information, see Automatic Reference Counting in C++.

Packages for 64-bit Windows Are Now Supported by C++Builder

C++Builder XE6 now supports the production of packages for 64-bit Windows. Previously, C++Builder supported production of packages only for 32-bit Windows. The BCC64 compiler produces .bpl files for Win64. Note that C++Builder does not produce dylibs for the Mac, or packages for the iOS and Android platforms. For these platforms, static libraries can be used.

Differences between Win32 and Win64 packages:

  • For Win64, the compiler exports code elements marked as PACKAGE if they are defined in the current translation unit. For classes, if one non member is defined, the class is exported. If no definition is seen, the compiler will treat the code element as imported. This behavior is different from Win32.
  • You must use PACKAGE for both Win32 and Win64, but Win64 exports only if there is a definition present. This requirement applies to variables, functions and classes that are meant to be exposed to consumers of the Package.


class PACKAGE TTest : public System::TObject {
  int FProp;
  __property int Prop = {read=FProp, write=FProp};
  __fastcall TTest(void);
  __fastcall virtual ~TTest(void);
PACKAGE bool GoodieFlag;
PACKAGE void __fastcall SuperFunc(const System::UnicodeString S);

Requirements for Win64 packages:

  • For exporting a component class from a package, ensure at least one non-inline member for each component (this is done for you by the Component > New Component wizard).
  • If you previously set the Package Output Directory to produce a Win32 package, make sure to change the path for your Win64 project on the Tools > Options > Environment Options > C++ Options > Paths and Directories (C++) page so that your Win32 package is not overwritten.

HPPEMIT Delphi compiler directives for Mobile Apps

You can now use ${HPPEMIT} directives for linking and generating C++ namespace declarations:

  • {$HPPEMIT NOUSINGNAMESPACE} suppresses the generation of the "using namespace <unit-name>;".
  • {$HPPEMIT LINKUNIT} replaces #pragma link for the Android and iOS device target platforms.

For more information, see $HPPEMIT.

C++ Compiler Changes for XE6

Declarations Now Require a Type (Clang-based C++ Compilers only)

  • Our Clang-based C++ Compilers (BCC64, BCCIOSARM, and BCCAARM) now enforce the requirement that declarations have a type in C++. This means you cannot use an implicit "int" in declarations, and so, for example, you now receive an error if WinMain has no return type, as in:
The above code now generates the following error:
 C++ requires a type specifier for all declarations
To remedy this error, update the code to read:

Open Array Definitions Now Use Data_High Instead of Data_Size

To clarify that the second parameter in an open array definition is the size of the array minus 1, the Data_Size parameter has been renamed Data_High.

For more information, see "Support for Open Arrays" in Open Arrays.

C++ LD Linker Disables .map File Generation

The Generate .map symbols file option is now disabled for both iOS and Android. If you need to generate a .map file, go to Project > Options > C++ Linker and select Generate .map symbols file.

Find Definitions/Find References

Clang-based C++ Compilers (BCC64, BCCIOSARM, and BCCAARM) support the new Find Definitions and Find References feature. RAD Studio provides the Find (C++) commands on the context menu when you right-click an identifier in the Code Editor. Depending on the identifier type, these commands return various information that increases the productivity of your work. For example, you can get all references to the selected identifier in the entire project, the identifier declaration, the base or derived classes (when the identifier refers to a class), and so on.

This feature is introduced with some detail in "IDE Changes in XE6" (#New Menu Entries and Results Panes for C++ Find References / Find Definitions).

For more information, see Find Definitions and References (C++).

Delphi Compiler Changes

The $LIBVERSION compiler directive no longer attaches library version data after the file extension, such as .dll, .dylib, .bpl, .map, .rsm, and so forth. Instead, library version data is inserted after the $LIBSUFFIX string, if present, and after the file name, but before the generated extension.

These directives ($LIBPREFIX, $LIBSUFFIX, and $LIBVERSION) can all be set on the Project > Options > Description page.

FireMonkey Changes

FireMonkey Supports C++ Android

The FireMonkey Mobile Application wizard now supports the Android target platform for C++ mobile applications. Also see Android Mobile Application Development.

Detection of Unsupported Android Device Architecture

When you launch a FireMonkey application on a device that has an unsupported CPU architecture, the application now displays an error message on the device:

Application not supported by this device 

To implement this feature, the Deployment Manager includes three small native-code libraries in your Android .apk package. These libraries are built for architectures that are not supported by FireMonkey applications:

  • ARMv6
  • Intel x86
  • MIPS

The code in these three libraries displays the error message.

You can see these native libraries in the Deployment Manager (see the highlighted lines):


Important: When building your application for publishing to the Google Play store, you should disable these additional libraries by unchecking them in the Deployment Manager. This prevents them from being included in your .apk package and allows the Google Play store to properly determine the device requirements for your application.

For example:

Note: Devices running Android 4.0.x (including some Kindle Fire tablets) might incorrectly report that the application is not compatible (this is due to a bug in the Android 4.0.x library loader). To resolve this issue, either install a newer version of Android on the device or remove the ARMv6 (armeabi) native library from deployment, by unchecking the armeabi library in the Deployment Manager, as shown in the previous image.

For a list of supported Android devices, see Android Devices Supported for Application Development.

Support Dropped for Mac OS X Lion (10.7)

We continue to support Mountain Lion (10.8) and now we support the new Mavericks (10.9).

For more information, see FireMonkey Platform Prerequisites and Mac OS X Application Development.

In-App Payment Services

In-app payment services enable you to sell digital content directly within your iOS and Android applications. FireMonkey now provides a component, TInAppPurchase, which makes it easy to add support for the Google Play and iTunes in-app payment services.

For more information, see Adding In-App Payments to Your Mobile Apps.

Advertising Services

Advertising services enable you to show ads on your iOS and Android applications to obtain income. FireMonkey now provides a component, TBannerAd, which makes it easy to add support for the AdMob and iAd advertising services.

For more information, see Adding Advertising to Your Mobile Apps.

New FireMonkey Style for Google Glass

FireMonkey provides a new style for the Google Glass device. The style is available at:


The GoogleGlass.fsf style is optimized for the Google Glass user interface and resolution.

You can add GoogleGlass.fsf to your Google Glass applications, following the steps in Adding a Custom Style to Your FireMonkey Application.

For more information, see Creating Applications for Google Glass.

GPU Canvas Can Be Enabled on Desktop Platforms

The GPU canvas is used by default on mobile platforms. Now you can use the GPU canvas on Windows as well. To enable the GPU canvas, just set the global variable FMX.Types.GlobalUseGPUCanvas to true in the initialization section.

In addition to GPU rendering, the GPU canvas uses text-rendering technology, which is especially valuable when handling text.

Changes to FMX.Grid

TGrid was internally refactored in order to improve performance and its scrolling behavior. TGrid delegates the drawing of cells to the grid columns. Each column can draw its cells by using the default drawing method, or by using the IDrawableCell interface.

Also, now it is possible to handle custom cell drawing using events from TGrid. There are two new drawing events on TCustomGrid: OnDrawColumnCell and OnDrawColumnHeader.

Several behavior and appearance properties are accumulated in one grid property: TCustomGrid.Options.

Other new features include:

Changes to FireMonkey Enumerated Types

Enum Identifier Names Now Have No Prefixes

In XE6, FireMonkey enumerated types are handled as scoped enumerations, and identifier names in enumerated types are redeclared, deleting their prefixes.

For example in XE5, TVKAutoShowMode was defined with the vkas prefix:

TVKAutoShowMode = (vkasDefinedBySystem, vkasNever, vkasAlways); // XE5
TVKAutoShowMode = (DefinedBySystem, Never, Always); // XE6

The prefixes on enumeration identifiers made the names unique in the global scope. Other examples of scoped enums in FireMonkey include TPaintStage.

Your legacy code that contains old prefixed identifiers, such as vkasDefinedBySystem, should still compile without errors. However, for any prefixed identifier, the compiler generates a warning that informs you that you are using an obsolete enumeration identifier and that you should substitute the correct name.

Enum Member Names Must Be Qualified with the Enum Name

Most FireMonkey units enable the {$SCOPEDENUMS ON} compiler directive (also see Strongly Typed Enums (C++0x)). The enabled {$SCOPEDENUMS ON} compiler directive states that all identifiers defined in enumerated types declared after this directive (until the nearest {$SCOPEDENUMS OFF} directive) are not added to the global scope. In this case, to specify a member of a scoped enumeration, you must qualify the member with the type of the enumeration.

For example, the TVKAutoShowMode enumerated type is now defined as:

TVKAutoShowMode = (DefinedBySystem, Never, Always);

Because of the {$SCOPEDENUMS ON} directive, the TVKAutoShowMode identifiers (DefinedBySystem, Never, and Always) should be qualified with the enumerated type name, such as:


New and Changed FireMonkey API

New SelectDirectory Function

FMX.Dialogs.SelectDirectory has been added, and it opens a directory selection dialog that is similar to Vcl.FileCtrl.SelectDirectory.

New Methods in FMX.WebBrowser.TWebBrowser

  • For the TWebBrowser component, FireMonkey now provides the LoadFromStrings and EvaluateJavaScript methods:

For more information and samples, see Mobile Tutorial: Using the Web Browser Component (iOS and Android).

New Date/Time Controls

FireMonkey provides two new components that serve as the date and time controls for your applications:

  • TDateEdit: Represents a single-line editable text box containing a date. When you click or tap the TDateEdit control, it displays a date picker that allows you to select a date.
  • TTimeEdit: Represents a single-line editable text box containing a specified time. When you click or tap the TTimeEdit control, it displays a time picker that allows you to select a time.

Note: TCalendarEdit has been deprecated. Please use TDateEdit instead.

For more information and samples, see Mobile Tutorial: Using a Calendar Component to Pick a Date (iOS and Android).

TPixelFormat Enumeration

The FMX.PixelFormats unit has been refactored and is now part of FMX.Types (such as the new FMX.Types.TPixelFormat enumeration). For consistency and clarity, the values for the new TPixelFormat are different from the values that were used for FMX.PixelFormats.TPixelFormat.

  • Functions to convert between different pixel formats have also been moved into FMX.Types. This includes:
  • Here is the logic to interpret the new FMX.Types.TPixelFormat enumerations:
    • The order of letters in enumerations is the physical order of channels:
      • "R" means Red.
      • "G" means Green.
      • "B" means Blue.
      • "L" means Luminance.
      • "A" means Alpha.
    • If there is no number at the end, each component has 8 bits.
      Example: RGB means 8 bits for red, 8 bits for green, and 8 bits for blue.
    • If there is a number at the end, this number of bits corresponds to each of the channels.
      Example: RGBA16 means 16 bits for each of the red, green, blue, and alpha channels, with 64 bits in total (16 + 16 + 16 + 16).
    • The total number of bits is rounded up to either 8, 16, 32, or 64 bits.
      Example: RGB (8 + 8 + 8 = 24) has 32 bits (rounded up to 32).
    • If there is an "F" at the end, this is a floating-point pixel format; otherwise, it is an integer format.
      In FireMonkey, we typically assume that all integer formats are treated as unsigned integer "normalized" format (that is, the lowest and highest integer values are mapped to the 0.0 - 1.0 range in shaders).
    Exceptions to the above rules:
    • BGR_565 is a 16-bit format with 5 bits for the Blue and Red channels, and 6 bits for the Green channel.
    • BGR5_A1 is a 16-bit format with 5 bits for each of the Red, Green, and Blue, and 1 bit for the Alpha channel.
    • BGR10_A2 is a 32-bit format with 10 bits for each of the Red, Green, and Blue, and 2 bits for the Alpha channel.
    • RGB10_A2 is the same as above (but the physical order of RGB channels is inverse).

TAlphaColorF Record/Struct

  • System.UITypes.TAlphaColorF is a new color type that treats each R, G, B, and A component as floats.
    • Overloaded operators allow adding, subtracting, and multiplying colors by using normal operations, such as:
      FinalColor := (FirstColor + SecondColor) / 2
    • Previously, pixel format conversion relied on TVector3D, which was treated as color, but now conversion uses TAlphaColorF.

TintColor and IconTintColor Properties in Buttons, TListView Text Buttons, and Toolbars

  • For the TButton and TSpeedButton components, FireMonkey provides the TintColor and IconTintColor properties that determine how to tint a button:
    • TintColor specifies the button background color.
    • IconTintColor specifies the button icon color for styled buttons.
  • For the TToolBar component, FireMonkey provides the TintColor property that determines how to tint a toolbar.
  • For the TListItemTextButton class, FireMonkey provides the TintColor property that allows you to apply a tint to TListView text buttons.

For more information and samples, see the following tutorial sessions:

EnumControls Can Skip Controls by any Criteria

FMX.Controls.TControl.EnumControls has been deprecated and replaced with a newer version by the same name. You should begin to use the new version in your code.

  • In previous releases, the TControl.EnumControls procedure expected two parameters:
    • An anonymous procedure to call when visiting a control during the search.
    • A boolean argument that would determine whether or not to skip non-visible controls from the search.
    You could change the value of the <Done> parameter in the anonymous method at any moment to abort the search, and you could set <VisibleOnly> to True on the call to TControl.EnumControls to skip children of non-visible controls during the search.
  • In XE6, the new version of TControl.EnumControls allows you to skip controls and their children from the search, based not only on whether the controls are visible, but on any criteria you want.
    Now TControl.EnumControls expects only one parameter, an anonymous function. This function receives a control, and its return value determines what to do next: to continue the search as usual, to continue the search but skip the children of the received control, or to exit the search.

New members in the FMX.TabControl.TTabControl class

For the TTabControl component, FireMonkey now provides new methods and properties:

  • Add adds a new tab at the end of the tab control.
  • Insert adds a new tab at a specific position.
  • Delete deletes a tab from the tab control.
  • Next moves the active tab to the next visible tab.
  • Previous moves the active tab to the previous visible tab.

VCL Quality Changes for XE6

Enhancements for Taskbar Buttons on Windows 7 and 8

The new Vcl.Taskbar unit enables several enhancements for taskbar buttons in Windows 7 and Windows 8 applications.

Using taskbar buttons, you can now:

  • Show / update the progress of a specified progress bar in the taskbar button
  • Display several different color states representative of the associated progress bar
  • Overlay images on the application taskbar icon
  • Add multiple buttons on the thumbnail preview of the application in the taskbar
  • Register your 'tabs' (forms) to display more than one image in the taskbar preview.
    You can show the form as-is in the preview, or clip a region of the form, or generate a new image and display it.

Sensor Components Available to VCL Applications

VCL applications can now use sensor components such as TLocationSensor. The sensor components (TLocationSensor, TMotionSensor, TOrientationSensor, and others) have been moved out of FMX.Sensors and into the new RTL unit System.Sensors.Components. These sensor components are now registered so that they appear on the Tool Palette for both VCL and FMX applications.

Styles for VCL Applications

  • New VCL styles: We have two new styles for VCL applications that run on any of the supported Windows target platforms:
    • Glossy
    • TabletDark
  • New Tablet style: For a VCL application that targets a Windows tablet, you can set the TabletDark style, which is specifically designed for the Windows touch-based interface.
  • Mew Menu styles: The style used by the various menus now matches the current style of the application. The menus involved include the main menu, popup menus, and system menus and system dialogs.
    • You can disable menu styles for VCL applications (so that menus do not use the application style) by adding the following code to your application:
      TStyleManager.SystemHooks := TStyleManager.SystemHooks - [shMenus];
  • Setting the Style: To set the style used by your VCL application:
    • Select a Default Style on the Project > Options > Application > Appearance page.

Updates to TWebBrowser

See Updates to TWebBrowser in the RTL section.

RTL Changes

Using App Tethering for Cross-Device Interaction Between Applications

The RTL provides new components to give your applications the ability to interact with other applications running either on the same machine or on a remote machine. Using app tethering, your applications can:

The RTL provides password-based security for app tethering connections between applications. You can use this password-based system to implement your own security procedure. For example, you can:

  • Make your applications connect automatically when they discover each other, transparently to your users.
  • Let your users manually enter a password in both applications to pair the apps.

The app tethering feature does not depend on a specific transport or protocol. In XE6, the RTL supports Ethernet connections between applications on the same local areal network (LAN), including applications running on the same device. You can implement your own adapters to support new transports and protocols using the app tethering API.

Updates to TWebBrowser

The web browser available on Windows (SHDocVw.TWebBrowser) has been updated to the latest version of Internet Explorer.

Database Changes

FireDAC Changes

  • TFDMemTable: Design-time enhancements enable you to load and save data from binary, XML, and JSON files. You can also assign data from other datasets to TFDMemTable at design time.
  • Data Explorer: The Data Explorer now contains a FireDAC node that enables you to drag\drop FireDAC components onto forms, to create FireDAC connections in the Data Explorer, and so forth.
  • Local SQL improvements better handle ad-hoc datasets:
    • TFDCustomLocalSQL and TFDLocalSQL contain API changes.
    • A single TFDLocalSQL can handle several schemas:
      • DS connection object can be not only TObject, but also IInterface.
      • DS save points can be int64.
      • Automatic temp / garbage datasets removal.
      • Registry for custom dataset adapters.
  • Streaming refactoring and JSON serialization format:
  • New FireDAC Informix native driver:
    • Based on Informix ODBC driver.
    • Supports both Win32 and Win64.
  • TFDPhysXxxxDriverLink component usage is now optional:
    • FireDAC design-time code automatically adds the required FireDAC driver implementation unit to the "uses" clause.
    • Use the TFDPhysXxxxDriverLink component when you need to set up a DBMS client library.
    • FireDAC supports SQL Server 2008 table valued parameters.
      • Only the ptInput parameter type is supported (MSSQL limitation).
      • Table valued parameters are of the ftDataSet data type.
      • For a stored procedure, TFDParam.DataTypeName is optional; for a DML command, TFDParam.DataTypeName is mandatory.
  • Control of the automatic and persistent fields of a data set:

Informix connection definition sample for FireDAC


SQL Server table type and stored procedure for FireDAC

     create type TVPType as table(Code integer, Name varchar(100), Notes varchar(max))
     create table TVPTab(Code integer, Name varchar(100), Notes varchar(max))
     create procedure TVPProc(@Items TVPType readonly)
       delete from TVPTab;
       insert into TVPTab (Code, Name, Notes)
       select Code, Name, Notes
       from @Items;

SQL Server TVP usage in Delphi for FireDAC

     // Automatic procedure metadata retrieval and setup
     FDStoredProc1.StoredProcName := 'TVPProc';
     FDStoredProc1.Params[1].AsDataSet.AppendRecord([1, 'str1', 'long value 1']);
     FDStoredProc1.Params[1].AsDataSet.AppendRecord([2, 'str2', 'long value 2']);
     FDStoredProc1.Params[1].AsDataSet.AppendRecord([3, 'str3', 'long value 3']);

     // Manual procedure setup
     FDStoredProc1.FetchOptions.Items := FDStoredProc1.FetchOptions.Items - [fiMeta];
     FDStoredProc1.StoredProcName := 'TVPProc';
     FDStoredProc1.Params.Add('@RETURN_VALUE', ftInteger, -1, ptResult);
     oDS := TFDMemTable.Create(nil);
     oDS.FieldDefs.Add('Code', ftInteger);
     oDS.FieldDefs.Add('Name', ftString);
     oDS.FieldDefs.Add('Notes', ftMemo);
     with FDStoredProc1.Params.Add('@Items', ftDataSet, -1, ptInput) do begin
       DataTypeName := 'TVPType';
            AsDataSet := oDS;
     FDStoredProc1.Params[1].AsDataSet.AppendRecord([1, 'str1', 'long value 1']);
     FDStoredProc1.Params[1].AsDataSet.AppendRecord([2, 'str2', 'long value 2']);
     FDStoredProc1.Params[1].AsDataSet.AppendRecord([3, 'str3', 'long value 3']);

     // SQL query execution:
     FDQuery1.SQL.Text := 'insert into TVPTab (Code, Name, Notes) select Code, Name, Notes from :t';
     oDS := TFDMemTable.Create(nil);
     oDS.FieldDefs.Add('Code', ftInteger);
     oDS.FieldDefs.Add('Name', ftString);
     oDS.FieldDefs.Add('Notes', ftMemo);
     with FDQuery1.Params[0] do begin
       DataTypeName := 'TVPType';
       AsDataSet := oDS;
     FDQuery1.Params[0].AsDataSet.AppendRecord([1, 'str1', 'long value 1']);
     FDQuery1.Params[0].AsDataSet.AppendRecord([2, 'str2', 'long value 2']);
     FDQuery1.Params[0].AsDataSet.AppendRecord([3, 'str3', 'long value 3']);

Push Notifications for iOS and Android

The REST BaaS framework (Backend As A Service) allows you to use the Kinvey or Parse BaaS providers in your mobile apps in order to:

  • Create, retrieve, update, and delete objects
  • Signup, login, retrieve, update, and delete users
  • Upload, download, and delete files or streams
  • Query objects and users
  • Send push notifications
  • Register for and receive push notifications on a device

The REST.Backend API units allow you to execute Kinvey or Parse REST API methods. These units declare methods that map directly onto the REST API documented on the Kinvey and Parse Web sites. You can use these units to write code to call REST API endpoints in either Parse or Kinvey.

  • The code written using the REST.Backend API units is specific to either Kinvey or Parse. For example, you would use either REST.Backend.KinveyProvider or REST.Backend.ParseProvider.
  • Our BAAS framework is based on our REST API framework. To enable push notifications on Android, we require Google Cloud Messaging (GCM) support to receive the push notifications. Kinvey supports Google Cloud Messaging with their REST API, but Parse does not currently support Google Cloud Messaging with their REST API:
    • For Android, you must use Kinvey.
    • For iOS, you can use either Parse or Kinvey.

The REST.Backend components support BaaS services in a general or abstract way. The code written using these components is not specific to Kinvey or Parse. For example, when the TBackendStorage component is used to create an object, the code is the same whether creating a Kinvey object or a Parse object.

The application should have a provider component, such as TKinveyProvider or TParseProvider, that contains the connection information for the Cloud service. To connect a provider component with a service component, set the "Provider" property such as TBackendStorage.Provider.

In order to receive push notifications, you need to set up the messaging service (APS or GCM), the device, the Cloud service (Kinvey or Parse), and the RAD Studio application.

For instructions on setting up and using remote notifications with your mobile apps, see Mobile Tutorial: Using Remote Notifications (iOS and Android).

Apache Server Support Added

DataSnap and WebBroker now support the creation of Apache modules in the following wizards:

Web.Win.Sockets Unit Converted into Product Sample

Web.Win.Sockets has been removed from the source delivered with RAD Studio.

  • For Delphi: Web.Win.Sockets is still delivered in the product as a Delphi VCL sample named InetWinSockets.
    • You can continue to use Web.Win.Sockets in a Delphi application by building the sample and installing it as a component.
    • The InetWinSockets product sample is installed by default in:
    C:\Users\Public\Documents\Embarcadero\Studio\15.0\Samples\Object Pascal\VCL\InetWinSockets
  • For C++: Web.Win.Sockets is still delivered in the product as a package (InetWinSockets.bpl).
    • To load the package:
      1. Create a C++ VCL application, choose Component > Install Packages, and click Add.
      2. Browse to C:\Users\Public\Documents\Embarcadero\Studio\15.0\Samples\Object Pascal\VCL\InetWinSockets, select InetWinSockets.bpl, and click Open.
      This installs the Internet category of components in the Tool Palette (including TTcpClient, TWebDispatcher, TXMLDocument, and all the other components of WinSockets).

Documentation for WinSockets can be found on previous docwikis, such as Instead of Web.Win.Sockets, consider using the comparable RTL sockets solutions in the System.Win.ScktComp unit, such as: http://docwiki.embarcadero.com/Libraries/XE5/en/Web.Win.Sockets and

IDE Changes for XE6

Google Glass Design Device Added to Form Designer

The Mobile Form Designer provides a Google Glass design-time device now:


For more information, see Creating Applications for Google Glass.

New Icons in the IDE

Icons have been updated throughout the product.

For example, the icon representing the project group in the Project Manager and other pages in the IDE has changed from ProjGroup.bmp to ProjGroupNew.png.

Please note that in some of the documentation, the icons are not yet updated.

New Options in the Deployment Manager

  • The new Overwrite option allows you to choose files that you do not want to deploy, specifically so that you can avoid overwriting files on the target device. The Overwrite option is set to Always by default. To change the option to Never, click the new Overwrite ChangeOverwriteValueforSelectedItems.png icon on the Deployment Manager toolbar menu.
  • The new Keep added files option allows you to keep any files that you manually added to your project after reverting the configuration to the default options for the selected platform. The Keep added files option is enabled by default, and you can change this value by clicking the Revert DMgrRevert.png icon. The Please specify the action dialog box opens, allowing you to select or clear the Keep added files option.

Changes in the SDK Manager for Android Platforms

  • The properties for an Android SDK version are now organized in three different tabs: SDK, NDK and Java. The SDK, NDK and Java fields are each organized on the corresponding tab, so, for example, it is easier for you to add or modify an SDK version.
  • Two new fields on the NDK tab allow you to introduce NDK Library paths for the two personalities:
    • C++Builder NDK Library path
    • Delphi NDK Library path.
    Clicking the ellipsis [...] button for either of these paths displays a Directories dialog box that allows you to browse, add, and manage the paths.


Path Names Have Changed

The names have changed slightly for the RAD Studio installation path (in Program Files (x86)) and for the documents path (in /Users/Documents), as follows:

  • Installation path [($BDS) environment variable]:
    • XE5: C:\Program Files (x86)\Embarcadero\RAD Studio\13.0
    • XE6: C:\Program Files (x86)\Embarcadero\Studio\14.0
  • InterBase redist path [($IBREDISTDIR) environment variable]:
    • XE5: C:\Users\Public\Documents\InterBase\redist\InterBaseXE3
    • XE6: C:\Users\Public\Documents\Embarcadero\InterBase\redist\InterBaseXE3
  • Documents path (where Samples, Styles, and Platform SDKs folders are located):
    • XE5: C:\Users\Public\Documents\Embarcadero\RADStudio\13.0\
    • XE6: C:\Users\Public\Documents\Embarcadero\Studio\14.0\

The correct new paths are used throughout the XE6 help.

New Menu Entries and Results Panes for C++ Find References / Find Definitions

The C++ Indexer feature enables Find References/Find Definitions for C++. C++ Indexing is supported by our Clang-based C++ Compilers (that is, for the 64-bit Windows, iOS, and Android target platforms).

To enable C++ indexing, enable the Index files for 'Definitions and References' option, located here:

  • For the current project, choose Project > Options > Project Properties.
  • For new generated projects, choose Tools > Options > Environment Options > C++ Options > Project Properties .

After indexing, the C++ Find menu commands are available on the Code Editor Context Menu.

The new context menu commands on the Code Editor are:

You can access the four new results panes for the C++ Indexer functionality through:

Project Options Changes for XE6


New Orientation Page for Mobile Apps Number1.png

The Orientation options previously on the Application page have been moved to a separate page. To access the new Orientation page, choose Project > Options > Application > Orientation.

New Option on the Delphi Compiler Number2.png

The new Use MSBuild externally to compile option on the Delphi Compiler page sets your project to be built outside the IDE using MSBuild. This option is False by default. To enable this option, choose Project > Options | Delphi Compiler .

This new option solves an Out of Memory problem that might occur when you build extremely large projects consisting of applications and libraries.

New Key on Version Info Page for Android

The new hardwareAccelerated key-value pair on the Version Info page enables hardware acceleration for your entire application. This key-value adds the hardwareAccelerated attribute to the <application> tag on the AndroidManifest.xml file; the value is true by default.


To access the Version Info page, choose Project > Options > Version Info.

New Options for the C++ Linker

  • For all Mobile platforms:
    • Generate .map symbols file: This option generates a mapfile in .\OutputFolder\ProjectName.map.
    • Remove the temporary .lnk linker after linking: This option removes the temporary linker file in .\OutputFolder\ProjectName.lnk.
  • For the iOS Device platform:
    • Link with Regular Expressions: This option links with the regular expressions library.

To access the C++ Linker page, choose Project > Options | C++ Linker.

Run Commands Provide New -cleaninstall Parameter for Mobile Platforms

The default behavior has changed for the Run commands on your mobile projects, for both Run and Run Without Debugging. When you run an application on a mobile device that contains a previously installed application with the same package name:

  • Previously, the Run commands uninstalled the data and cache directories in addition to the executable itself.
  • Now the Run commands uninstall only the executable, and leave the data and cache directories intact on the mobile platform.

You can, however, specify that the previous behavior should be used (any pre-existing data and cache directories should be deleted when you run an application on a mobile device). To do this, select Run > Parameters, and add the following parameter:


For more information, see "Running Your Application with Clean Data and Cache Folders" in:

Also notice that if you change the platform configuration for a specific project, you should set the -cleaninstall parameter by going to Run > Parameters; otherwise you might get an error.

Changes in the Entitlement List for iOS and OS X

The Entitlement List page for iOS has been revised. You can access the Entitlement List through Project > Options > Entitlement List.

Apart from the Entitlement List page for iOS, now you can manually edit the entitlement files for iOS and OSX. When you build an application for either the iOS or the Mac OS X target platform for the first time, an <Entitlement.TemplateiOS.xml>, or <Entitlement.TemplateOSX32.xml> template is added to your project folder. You can also predefine entitlement keys for all your projects as a starting point.

See Customizing Your Entitlement List for more information.

Windows API Changes for XE6

DirectX 11 Supported in XE6

Winapi has been extended with new units that provide Delphi applications access to the DirectX 11 API:

  • Winapi.D3D11
  • Winapi.D3D11sdklayers
  • Winapi.D3D11Shader
  • Winapi.D3DCommon

For help using DirectX, see the DirectX Graphics and Gaming guide.

OpenGL 4.3 and Older Supported in XE6

A new unit, "Winapi.OpenGLext", provides support for OpenGL versions 1.2 to 4.3. To use the latest OpenGL features, include this unit in your uses section, and call InitOpenGLext:


"Winapi.OpenGL", the unit that provides support for OpenGL 1.1, has been updated and now supports the whole OpenGL 1.1 API.

For help using OpenGL, see:

Refactoring of Libraries

New units

Renamed units

  • Datasnap.Xmlxform (renamed from Xmlxform (TXMLTransformClient / Xmlxform TXMLTransformProvider only))
  • FireDAC.Phys.DS (renamed from FireDAC.Phys.DataSnap)
  • System.Messaging (renamed from FMX.Messages)
  • Xml.XmlTransform (renamed from Xmlxform (except TXMLTransformClient / TXMLTransformProvider))
  • The various FMX.Helpers units, which contain functions useful for component development on mobile platforms, have been refactored, and moved into units in the RTL, such as Macapi.Helpers, Androidapi.Helpers, and iOSapi.Helpers.


Online Help Changes for XE6

Product Samples Changes for XE6

The Product Samples in XE6 have new improved structure of folders. Samples Descriptions describes the new locations of source files for Product Samples. By default, Setup installs the Product Samples using the following structure of folders:

  • C:\Users\Public\Documents\Embarcadero\Studio\14.0\Samples\:
    • Object Pascal - Delphi samples.
      • FireMonkey Desktop - FireMonkey samples for Windows and OS X platforms.
      • Mobile Samples - FireMonkey samples for iOS and Android platforms. These are fully built, complete applications that illustrate how a certain technique or feature works.
      • Mobile Snippets - FireMonkey Mobile Snippets for iOS and Android platforms. These are small projects that are used to demonstrate specific FireMonkey mobile functionality. They help you to understand how to implement basic mobile functionality using RAD Studio.
      • Database - Samples demonstrating how to use supplied with RAD Studio tools (like FireDAC) for programing database applications.
      • Datasnap - Samples demonstrating how to use Datasnap connectors for mobile devices developing DataSnap Applications.
      • LiveBindings - Samples demonstrating how to use LiveBindings developing RAD Studio applications.
      • RTL - Samples demonstrating how to use RTL library.
      • VCL - Samples demonstrating how to use VCL library.
    • CPP - C++Builder samples
      • FireMonkey Desktop
      • Mobile Samples
      • Mobile Snippets
      • Database
      • DataSnap
      • RTL
      • VCL
    • Data - Contains sources of databases used by other Product Samples.
    • UML - The UML 2.0 sample project is designed to help you explore the UML modeling features while working with design projects.

The help pages for the samples have been updated with the correct location information.

New Product Samples in XE6

New Product Samples added for XE6 include the following:

New Product Samples for XE6 lists all Product Samples added in XE6.

See Also