What's New

From Appmethod Topics
Jump to: navigation, search


What's New in Appmethod 1.14

C++ Has Been Added to Appmethod

Appmethod 1.14 now supports the C++ programming language:

  • Appmethod C++ supports all the same target platforms that Object Pascal does, except that C++ does not support the iOS Simulator.
For more information, see Multi-Device Applications.

Automatic Reference Counting (ARC) Is Enabled for C++ Android

  • C++ Android uses automatic reference counting (ARC) in order to be compatible with Object Pascal Android.
    All the ARC management is handled inside the C++ Android compiler, so you should not need to do anything different in order to work in the C++ Android ARC environment. Your C++ code can still use pointer syntax for an Object Pascal class instance. The C++ Android 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 Supported by C++

C++ supports the production of packages for 64-bit Windows. The C++ compiler produces .bpl files for Win64. Note that Appmethod C++ 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 that for 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 Object Pascal 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 1.14

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. Appmethod 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 1.14" (#New Menu Entries and Results Panes for C++ Find References / Find Definitions).

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

Object Pascal 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

Detection of Unsupported Android Device Architecture

When you launch a FireMonkey application on a device that has a CPU architecture that Appmethod does not support, 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 1.14, 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 = (DefinedBySystem, Never, Always); // 1.13
TVKAutoShowMode = (DefinedBySystem, Never, Always); // 1.14

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 DefinedBySystem, 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.

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 1.14, 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.

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 1.14, 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.Stan.StorageBin / XML / JSON units.
    • Each serialization format now moved into loosely coupled FireDAC.Stan.StorageXxx unit.
    • TFDStanStorageXxxLink component added for each format.
    • TFDResourceOptions.StorePrettyPrint added to control XML / JSON formatting.
    • JSON serialization format has been implemented, adding sfJSON to TFDResourceOptions.DefaultStoreFormat.
  • 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 Object Pascal 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 Appmethod 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:

IDE Changes for 1.14

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:
    • Appmethod C++ NDK Library path
    • Object Pascal 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 Appmethod installation path (in Program Files (x86)) and for the documents path (in /Users/Documents), as follows:

    • 1.14: C:\Program Files (x86)\Embarcadero\Studio\14.0
  • InterBase redist path (($IBREDISTDIR) environment variable):
    • 1.13: C:\Users\Public\Documents\InterBase\redist\InterBaseXE3
    • 1.14: C:\Users\Public\Documents\Embarcadero\InterBase\redist\InterBaseXE3
  • Documents path (where Samples, Styles, and Platform SDKs folders are located):
    • 1.13: C:\Users\Public\Documents\Embarcadero\Appmethod\13.0\
    • 1.14: C:\Users\Public\Documents\Embarcadero\Studio\14.0\

The correct new paths are used throughout the 1.14 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 newly 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 1.14


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 Object Pascal Compiler Number2.png

The new Use MSBuild externally to compile option on the Object Pascal 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 | Object Pascal 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 1.14

DirectX 11 Supported in 1.14

Winapi has been extended with new units that provide Object Pascal 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 1.14

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

What's New in the Help

See Also