Watch, Follow, &
Connect with Us

Embarcadero Blogs

Latest Posts

App Tethering : Sharing Transient Resources

posted @ Tue, 26 May 2015 20:00:08 +0000 by Malcolm Groves

Do-Say-See Tutorial: Use Delphi XE8 to build EMS e-mail checker service and client

Two weeks ago I was doing the EMS demo session for Delphi developers in London. That was good fun!

Would you like to do it yourself?

In this post you will find detailed steps of my demo. Enjoy!

The source code of this demo can be downloaded from Embarcadero Code Central.

There were some comments on social media, so I think that a disclaimer is in place. The demo "E-mail Checker" service does not check if a given e-mail address actually exists. The service is only as good as the regular expression used to validate if a given string looks like a valid e-mail address or not. It will for example tell that "hello@hello.c" is not a good one, because "c" is not a valid domain name. It is not perfect, you can use in production environment at your own risk only. It is just a simple EMS demo. Nothing more:-) Thanks Andrea Raimondi for bringing this up.

Do-Say-See Steps

Enterprise Mobility Services (EMS) is a new turnkey solution for today’s interconnected, distributed apps, offering an easy to deploy middleware server that hosts loadable custom API and data access modules. Based on open and standard technologies, including REST HTTP calls and JSON data formats, and providing major SQL database drivers along with an encrypted embedded and server SQL database. With its user management and authentication with user and API analytics, Enterprise Mobility Services is ideal for enabling secure access from mobile apps to Enterprise Databases. EMS is a middleware solution that is stateless, restful, scalable, and secure.

This step-by-step tutorial will walk you through the process of building an email checker app using Enterprise Mobility Services and Delphi XE8. The mobile app is going to be very simple. It will just contain an edit and a button. When the end user presses the button, the contents of the edit will be sent to the EMS service REST API that will validate if a given string is a valid email address using regular expressions.

First we need to create an EMS service and then we are going to create a multi-device app project for it.

Start Delphi XE8. From the “File” menu select “New” and then “Other”. In the “New Items” dialog click on the “Delphi Projects -> EMS”. Double-click on the “EMS Package” icon. That should display “EMS Package Wizard” window.

Each EMS package can contain zero or more resources with endpoints that extend the REST API of the EMS server.

On the “Package” tab of the wizard select the second option “Create package with resource”. Click on “Next” button.

In the second step of the wizard we need to give a new EMS resource a name and decide what file type to use for a class that is going to implement this resource. If we plan to use any non-visual components in the implementation of our resource it is handy to choose for a data module.

In the “Resource name” field enter “EmailChecker”. Keep “Data module” as selected file type. Click on “Next” button.

In the last step of the wizard we need to decide which endpoints to add to our resource. Each endpoint handles a different kind of HTTP request. We are going to keep the default selection: a generic HTTP GET request plus an HTTP GET request for a specific “item” in the resource. In case of our server we are going to use “Get” endpoint to return just the name of the service and the “GetItem” to perform the actual check if a given string is a valid email address.

In the “Endpoints” tab of the resource keep the default selection of “Get” and “GetItem”. Click on “Finish” button. That should generate a new EMS package project.

Now we need to save the project generated by the wizard in a location that makes sense to us and to give the unit and the project meaningful names. Notice that the project has the “bpl” extension, which means that this is a Delphi package that can be loaded into the executable and cannot be run standalone.

Click on the “File” and “Save All” menu option. Create “C:\demos\XE8\EMS\EmailChecker” directory on your hard drive. Save the resource unit as “uEmailCheckerRes” and the package project as “EmailChecker”.

The EMS package is loaded by the “EMS Development Server” that is located in the “bin” directory of our Delphi XE8 installation. We can verify this by going to “Debugger” tab in “Project Options”.

From the “Project” menu select the last item “Options”. Click on the “Debugger” node and highlight “Host application” option. Verify that it points to “EMSDevServer.exe”.

The actual code to check if a given string is a valid email address has already been written. We need to add the “RegExpressionsUtil” unit to our EMS server project.

Download the “RegExpressionsUtil.pas” file from the following URL:

Copy this file to the directory where you have saved the EMS package project (C:\demos\XE8\EMS\EmailChecker). Right click on the “EMailChecker.bpl” node in the Project Manager at the top right corner of the IDE. Select “Add…” from the context menu to add “RegExpressionsUtil.pas” file to the project.

In order to be able to use methods of the “TRegularExpressionsEngine” type in our EMS resource code, the first thing is to add “RegExpressionsUtil” unit to the “uses” clause. We could write this manually in the editor, but it is much faster and more fun to it with the wizard.

Make sure that the “uEmailCheckerRes” unit is open in the editor. In the “File” menu select “Use Unit…” to add to the “uses” clause of the EMS resource unit. Select “RegExpressionsUtil” and click on “OK”.

sWe need to modify the implementation of the “GetItem” method in our EMS resource to take the parameter “item” from the HTTP request sent by a client application and pass it to “TRegularExpressionEngine.IsValidEmail” method. If the method returns true, then we are returning “TJSONTrue” or “TJSONFalse” in the HTTP response body otherwise.

Replace the body of the “TEmailCheckerResource1.GetItem” method with the following code:

procedure TEmailCheckerResource1.GetItem(const AContext: TEndpointContext; const ARequest: TEndpointRequest; const AResponse: TEndpointResponse);
var LItem: string;
  LItem := ARequest.Params.Values['item'];

if TRegularExpressionEngine.IsValidEmail(LItem) then
  AResponse.Body.SetValue(TJSONTrue.Create, True)
  AResponse.Body.SetValue(TJSONFalse.Create, True);

Select “Save All” from “File” menu.

Now our EMS resource is ready and we can start creating a client for it. Before we do it let’s see if it works as expected. Let’s run it without debugging.

Click on the green arrow to run the project without debugging.

EMS Development Server has started and in the log window we can see useful information about loaded resources.

Verify that the EMS Development Server has been started.

We are going to test our EMS. If just click on the “Open Browser” button, the default web browser would start and invoke the built-in “version” resource. Any application that knows how to make an HTTP request can be a client for the EMS server. In our case this is a web browser. Later on we are going to build a mobile client app for the service.

Click on the “Open Browser” button in the EMS Development Server window. Verify that the web browser displays JSON text with EMS version information.

Let’s test our “EmailChecker” endpoint. First we are going to pass to it a string that is not a valid email address. For example “hello”. The server should return “false”.

In the web browser replace “version” with “EmailChecker/hello” and press enter. Verify that the web browser displays “false” string.

Let’s try again, but this time we are going to pass to our “EmailChecker” resource a string that looks like a valid email address. For example This time we should see “true”.

Replace “hello” with and press enter. Verify that the web browser displays “true” string.

Now we are going to build a client application for our EmailChecker EMS resource. We do not need to stop the server. Let’s keep it running. Just right-click on the “Project Group” and select “Add New Project”.

Right-click on the “Project Group” icon in the Project Manager in the top right corner of the Delphi IDE and select “Add New Project” from the context menu.

We are going to create a new Delphi multi-device application that can be compiled for iOS, Android, Windows and Mac from the same code.

In the “New Items” dialog select “Multi-device Application” in the “Delphi Projects” category. Click on OK.

We are going to use an empty application template for our client app.

Select “Blank Application” template in the new “Multi-device Application” wizard and click OK.

It is always a good idea to save your work. We are going to save the new project in the same directory as our EMS service to keep things simple.

Click on “Save All…” in “File” menu. Save the main unit of the new project as “uFormClient”, the project as “EmailCheckerApp” and the project group as “EmailCheckerGrp”.

Don’t forget about giving meaningful names to forms in your application! The name of the form will be “FormClient” and the caption “Email Checker”.

Click on the form to select it in the Object Inspector. Change the “Name” property of the form to “FormClient” and the “Caption” property to “Email Checker”.

We need an edit and a button in our application, so the end user can enter text into an edit and click on the button to verify if it is a valid email address or not. The fastest way of adding components to the form is via “IDE Insight”. I just need to press “Ctrl” and “.” keys at the same time to move focus to the IDE Insight and I can just start typing the name of the component I want to add.

Press “Control” and “.” on the keyboard to switch focus to the “IDE Insight” and start typing “TEdit”. Double click on the “TEdit” in the drop down list to add an edit control to the form. Move the control towards to the top left corner of the form.

In the same way we are going to add a button to the form.

Click on the red cross in the “IDE Insight” edit and type “TBut”. Double click on the “TButton” component to add it to the form.

The user interface of our application is going to be super simple. Just an edit and a button. We need to give a proper caption to the button.

Move the button under the edit control on the form, make it a bit wider and change its “Text” property to “Verify e-mail address”. Make the whole form a little bit smaller.

It is always a good practice to give controls meaningful names. Our user interface is ready. Now it is time to add some code to invoke the EMS EmailChecker resource.

Change the “Name” property of the edit control to “edtEmail”. Change the “Name” property of the button to “btnVerify”.

Let’s keep the structure of our client application clean. It is typically not a good idea to add non-visual components and data access logic directly to a form. It is better to put them in a separate data module. In this way the code is more maintainable. Let’s add a data module to our project for the components and code that is going to access our EMS resource.

In the “File” menu click on “New” and “Other”. In the “New Items” dialog select “Delphi Files” node in the tree view at then “Data Module”. Click OK to add it to the project.

We need to give proper names to the data module unit and to the data module itself. What about “DMEmailChecker”?

In the “File” menu click on “Save All”. Save the data module as “uDMEmailChecker”. In the Object Inspector change the “Name” property of the date module to “DMEmailChecker”.

The key component that provides access to the EMS server is “TEMSProvider”. Let’s add it to the data module.

Drop on the data module a “TEMSProvider” component.

We need to specify in the EMS provider component the host name and the port of our EMS server. In our simple demo the server is running locally, so we are going to enter “” as host and “8080” as the port number. In a real situation that would be the actual IP address of the machine which hosts the EMS server.

Change the “URLHost” property of the “EMSProvider” component to “” and the “URLPort” property to “8080”.

Now we can check if the EMS Provider component can connect to EMS server. We can just right-click on the provider and select “Test Connection”. Alternatively we can click at the “Test Connection” option at the bottom of the Object Inspector.

Right-click on the “EMSProvider1” component and select “Test Connection” from the context menu.

If we can connect to the EMS server, we should see a message with the EMS version information.

Verify that the connection is working. You should see the message with JSON-formatted EMS server version.

In order to invoke a resource in the EMS, we need to have a “backend endpoint” component. Let’s add it to the data module. In the “Resource” property we need to specify the URL resource we want to access. We also need to specify the “ResourceSuffix”, because we want to execute the GET endpoint that takes the “(item}” parameter. We can even check at design time if the resource is accessible right-clicking on the backend and selecting “Execute”.

Drop on the data module “TBackendEndpoint” component. Change the “Resource” property of the backend endpoint component to “EmailChecker”. Change the “ResourceSuffix” property to “{item}”. Right-click on the backend endpoint component and select “Execute”.

If we have not misspelled the resource name, we should get HTTP response code “200”, which means “OK”.

Verify that the endpoint can be executed. There should be a message “Response 200 – OK” displayed.

We need one last component in our data module – “REST Response”. This component needs to be connected to the endpoint backend and is used to store the response received from our backend. In our case that would be “true” or “false”.

Add to the data module “TRESTResponse” component. Change the “Response” property of the “BackendEndpoint1” component to “RESTResponse1”.

We also need to define the parameter that our “EmailChecker” endpoint expects. That’s why need to add an item to “Params” property of the endpoint component.

Select “BackendEndpoint1” component and click on the ellipsis button next to the “Params” property.

Let’s define a parameter. The “Value” property of the parameter is what is going to be sent to the email checker for validation. Let’s put here a string that looks like a valid email. We also need to set the “Name” property to “item”.

Click on the “Add New” button in the params editor window to add a new parameter to the collection. Set its “Name” property to “item”. Set its “Value” property to

We can test execute our email checker at design-time. If we execute the endpoint again, we should see what was sent back from the EMS service in the “Content” property of the response component. Yes. “” appears to be a valid email address.

Right-click on the “BackendEndpoint1” component and select “Execute” from the context menu. There should be a message “Response 200 – OK”. Click on the “RESTResponse1” component. Click on the ellipsis button next to the “Content” property. Verify that it contains text “true”.

Our components are all setup for invoking the email checker endpoint. Before starting with writing some code let’s remove the parameter value and the response data. Clearing the response data can be done very easily from the context menu of the REST response component.

Right-click on the “RESTResponse1” component and select “Clear Response Data” from the context menu.

REST response needs to be really sure that you really want to clear the response data. Yes. We want to clear it.

Click on OK to confirm that you want to clear the response data.

In the moment we are going to write code that will provide the “Value” of the parameter from the edit control.

In the “Structure” view click on the parameter “item” to select it in the Object Inspector. Clear the contents of the “Value” property.

Now we are going to implement public method “IsValidEmail” in our data module that will execute the “EmailChecker” endpoint. This is the method we are going to call from the user interface of our EmailCheckerApp.

Switch to code editor by pressing F12. In the “public” section of the data module type declaration of the “IsValidEmail” method as follows:

function IsValidEmail(s: string): boolean;

Press “Ctrl+Shift+C”. In the generated skeleton of the implementation of the method type the following three lines of code:

BackendEndpoint1.Params[0].Value := s;
Result := RESTResponse1.Content = 'true';

Save All.

Before we can use the data module in the code of the application form, we need to add it to its “uses” clause. The fastest way to do so is with the “Use unit” wizard.

Make sure that the “uFormClient” unit is active in the code editor. In the “File” menu click on “Use unit…”. Select the “uDMEmailChecker” unit and click on OK.

The last step is to add code to the form that will be executed when button will is pressed. The contents of the edit will be passed to “IsValidEmail” method of the data module and depending of the result appropriate message is displayed.

Double-click on the button component on the form and type in the following code in the generated “OnClick” event handler:

if DMEmailChecker.IsValidEmail(edtEmail.Text) then
  ShowMessage('"' + edtEmail.Text + '" is a valid email address')
  ShowMessage('"' + edtEmail.Text + '" is NOT a valid email address');

Save All.

The client application is now complete! Let’s run and verify that it works as expected.

Press the green arrow icon to run the client app without debugging. Enter to the edit control. Press on the button and verify that the message that the email is valid is dislayed.

That’s it! We have managed to create the complete system made of the EMS email checking service and a multi-device client app.

The source code of this demo can be downloaded from Embarcadero Code Central.

posted @ Tue, 26 May 2015 13:03:02 +0000 by Pawel Glowacki

New Video: IoT - Internet of Things - Embarcadero's Solution for Mobile Application Development

The way we experience and interact with devices is changing. Embarcadero Technologies breathes new life into existing applications by enabling developers to easily connect their apps to gadgets, devices, sensors, enterprise data, and cloud services.

Learn more about software application development solutions from Embarcadero.

posted @ Tue, 26 May 2015 11:45:00 +0000 by Tim Del Chiaro

Build Windows 10 apps with RAD Studio XE8 and this new VCL Windows 10 Style

Easily build Windows 10 apps now with RAD Studio XE8 and this great new VCL Windows 10 style.

The full release of Windows 10 is right around the corner and your end users will expect apps to adopt the new visual style. This is a great opportunity to get ahead of the curve and prepare your VCL app for Windows 10 today!

The new style works for VCL apps with RAD Studio XE8, C++Builder XE8, or Delphi XE8. XE8 customers can download the new Windows 10 VCL style by clicking here.

To showcase the new VCL style for Windows 10, I created a small sample application that you can see in the screenshots below. In this sample application, I also added a couple of TImage controls using flat icons for the plus icon, the search icon, the refresh icon and the drawer icon.

As you can see in the screenshots below, the window border style, system icons and UI controls such as TEdit, TButton, TCheckBox, TTrackBar etc. all have the new Windows 10 look and feel. In my sample app, I also added a slide in-drawer to show and hide the deposit history which is shown in a TListBox control. Scroll down to the bottom of this post for the code snippet.

Demo app running in full-screen mode on Windows 10:

Windows 10 VCL Style Full Screen

Demo app with BorderStyle = bsSizable on Windows 10:

Windows 10 VCL Style Bordered

Here is a code snippet from my demo for building a slide-in drawer. You could also place the hamburger icon (three line glyph) into the right panel and hide only a portion of the panel so that the hamburger icon is visible at all times. You could then reposition the glyph once the slide in animation is complete.

procedure ShowControlFromRight(AControl: TControl);
  I, Step: Integer;
  TickCount: DWord;
  if AControl.Visible then Exit;
  AControl.Align := alNone;
  AControl.Anchors := [];
  AControl.SetBounds(Form1.ClientWidth, 0, AControl.Width, Form1.ClientHeight);
  AControl.Visible := True;
  I := AControl.Left;
  Step := AControl.Width div 20;
    TickCount := GetTickCount;
    Dec(I, Step);
    if I > Form1.ClientWidth - AControl.Width then
      AControl.Left := AControl.Left - Step
      AControl.Left := Form1.ClientWidth - AControl.Width;
    while TickCount + 1 > GetTickCount do;
  until AControl.Left <= Form1.ClientWidth - AControl.Width;
  AControl.Anchors := [akTop, akRight, akBottom];

procedure HideControlToRight(AControl: TControl);
  I, Step: Integer;
  TickCount: DWord;
  if not AControl.Visible then Exit;
  AControl.Align := alNone;
  AControl.Anchors := [];
  Step := AControl.Width div 20;
    TickCount := GetTickCount;
    AControl.Left := AControl.Left + Step;
    while TickCount + 1 > GetTickCount do;
  until AControl.Left > Form1.ClientWidth;
  AControl.Visible := False;

procedure TForm1.Image2Click(Sender: TObject);
 if Panel2.Visible then
    HideControlToRight(Panel2) else

posted @ Wed, 20 May 2015 23:28:28 +0000 by sarinadupont

RAD Studio XE8: Learn What Developers are Saying & Offers Ending May 31st

Here's a copy of an email that will be going out this week with some info on what developers are saying about RAD Studio XE8 and a reminder of the special offers ending May 31. This is the US and Canada version. The buttons don't look quite right when pasting from the email into here but you can get the idea.

posted @ Wed, 20 May 2015 14:21:00 +0000 by Tim Del Chiaro

IoT in Action: Building a Modern Healthcare Application - Webinar resources and links

On Wednesday, May 20, 2015 I am presenting a webinar titled "IoT in Action: Building a Modern Healthcare Application". The webinar presents the development of connected, multi-device solutions for the healthcare industry, using Beacons and Bluetooth LE devices. During this session, David Intersimone, Vice President of Developer Relations and Chief Evangelist at Embarcadero, demonstrates how developers can use RAD Studio XE8, which supports Proximity Beacons and Enterprise Mobility Services Push Notifications, to build a modern medical application solution for a hospital or doctor’s office.

IoT in Action: Building a Modern Medical Application for a Hospital or Doctor’s Office

Digital devices are proliferating inside medical offices and hospitals, and Bluetooth wearables are being used to capture biometric information. These devices, which are part of the IoT landscape, are providing higher levels of patient monitoring, medical office productivity, and patient information management. Recognizing the potential of these connected devices to transform the everyday experience of visiting a healthcare provider, this webinar will give developers a first hand look into:

  • RAD Studio XE8 connected app development for Windows, OS X, iOS, Android and the Internet of Things
  • FireUI and VCL application development for desktop, smartphone, and tablet devices
  • Proximity-based application development using the new TBeacon component supporting the use of iBeacon and AltBeacon
  • Bluetooth LE development for state-of-the-art medical devices including Heart Rate Monitors, Digital Weight Scales, and more
  • Enterprise Mobility Services (EMS) support for Apple Push Notification Service (APNS) and Google Cloud Messaging (GCM)

Webinar Resource Links

The following are links to additional information used in the Webinar:

I will also upload the slides after the webinar is completed and provide a link here.

posted @ Wed, 20 May 2015 12:32:03 +0000 by David Intersimone

App Tethering : Sharing Persistent Resources Part 2

posted @ Tue, 19 May 2015 20:00:32 +0000 by Malcolm Groves

Today’s RAD Studio XE8 Live Online Deep Dive Workshop - Agenda/Times

RAD Studio XE8 Deep-Dive Online Workshop, Saturday, May 16, 2015 - 8:00am -1:00pm Pacific / 11:00am-4:00pm Eastern

Discover more about how to:

  • Make the most of your VCL Windows applications in a connected world
  • Move existing code up to new levels of scalability, performance and integration
  • Extend existing code and build new apps to embrace mobile, new devices and Internet of Things
  • Utilize high-performance, easy-to-use, enterprise database connectivity
  • Embrace the latest compilers and toolchains
  • Be the most productive you have ever been – for Windows and beyond!
  • …and much more!

Join us for all the technical developer fun -

The Workshop Agenda

Start Time Duration Topic Presenter(s)
8:00 5 Intro and Agenda David I
8:05 10 NEW! iOS64bit – OP and C++ David I
8:15 5 NEW! GetIt Package Manager: Access and install from the cloud, popular VCL and FMX source code libraries, components and tools like AsyncPro and Power PDF right from within the IDE. Get the updated TurboPack for free! David I
8:20 5 NEW! MapView component for iOS/Android David I
8:25 10 FireUI multi-device designer and NEW! Multi-device preview + TWebBrowser JimM
8:35 5 NEW! IDE Settings Migration JimM
8:40 5 XE8 Premium Styles – VCL and FMX Al
8:45 5 NEW! Box2D - A 2D physics engine for your VCL and FMX applications Al
8:50 20 ENHANCED! App Tethering: Now it’s easier than ever to extend your VCL and FMX desktop application UI, data and control to mobile and wearables via WiFi, ethernet or Bluetooth now with hooks for data Al
9:10 10 Break #1 BREAK
9:20 20 NEW! More than 20 New IDE Features for Coding Productivity: Code faster and more efficiently with new refactorings, multi-paste support, clipboard history, parenthesis matching, Smart Keys, Code Navigation Toolbar, project statistics and more. JimM
9:40 10 NEW! AppAnalytics: Finally understand exactly how your customers use your VCL or FMX app. Simply add the TAppAnalytics component and get instant access to application usage statistics through your cloud dashboard. David I
9:50 20 RECENTLY ADDED! Easily Add Parallel Processing to Your New and Existing VCL/FMX OP and C++ Apps: Delivering 2x to 8x performance gains on Multi-Core systems. David I & JimM
10:10 30 NEW! Unit Testing: It’s has never been easier or more complete with the new integrated DUnitX testing framework Nick Hodges
10:40 10 Break #2 BREAK
10:50 5 NEW! Native Platform HTTP/S VCL/FMX Support for Windows, Mac, iOS and Android: Makes must-have secure connections a snap. Al
10:55 25 ENHANCED! FireDAC: The best DAC gets better with Updates Management, dbExpress migration, SQLite encryption, InterBase XE7 Change Views. Stephen
11:20 10 Devices – BluetoothLE support (VCL via Win8.1, FMX) JimM
11:30 15 NEW! IoT, Beacons and More: Easily add IoT gadgets and sensors, like proximity beacons, into your existing Windows VCL and FMX apps. JimM
11:45 10 ENHANCED! Parse/Kinvey MBaaS Cloud Services: Easily power your VCL and FMX desktop and mobile application backend infrastructure in the cloud with user management, push notifications, data storage and more. David I
11:55 30 ENHANCED! EMS (Enterprise Mobility Services): Easily integrate your applications to your enterprise and to the world with Push Notifications, REST API publishing, external credentials, database connection pooling, client API component, new administrative app and more. Al
12:25 15 Deep Dive into a Modern Healthcare Application that uses EMS, InterBase XE7, smartphones, tablets, devices and proximity beacons David I
12:40 20 Summary and Final Q&A Everyone
13:00 300 Minutes  

posted @ Sat, 16 May 2015 15:48:25 +0000 by David Intersimone

Important InterBase XE 7 – Update 2

InterBase XE7 – update 2

InterBase XE7 update 2 is now available for Windows and Linux server and ToGo. This update is highly recommended for all users of InterBase XE7.

For what is new and resolved issues in InterBase XE7 Update 2, please see the online InterBase documentation. – but in short, following update 1 with some change view enhancements – update 2 contains a number of fixes to general bugs reported.

Working with reserved words.

A list of Known Issues is available in the documentation. One that I will highlight is the addition of CHANGE, CHANGED, INSERTED, UPDATED and DELETED as reserved words in InterBase XE7 due to the introduction of Change Views.

I have heard of a few cases where developers have SQL statements that have stopped workings because their tables have fields that are one of the reserved words, e.g. UPDATED; Its easily to ensure those keep working by putting field names in “quotes” in your SQL statement.

As we know a lot of developers don’t quote their field names, we are working towards either a hot-fix or an update for the future that will only work with these as reserved words IF Change Views are being used, however it is recommended that you add “quotes” to the fields in your SQL if you are at all in doubt.


For registered users, you can find the patch downloads at

Server Edition



ToGo & IBLite Edition

Registered Users Downloads

Developer edition and Trial


The post Important InterBase XE 7 – Update 2 appeared first on Stephen Ball's Technical Blog.

posted @ Fri, 15 May 2015 10:40:02 +0000 by Stephen Ball

Creating Custom Multi-Device Preview Devices

In RAD Studio XE8, we introduced the Multi-Device Preview. The Multi-Device Preview provides a design time view of what your application is going to look like on a wide range of devices. 

In RAD Studio XE8, you can easily add your own device to the Multi-Device Preview to see what your application is going to look like on a specific device.

In this quick tutorial, I am going to show you how to add the Moto360 Android watch as a custom preview device.

1. Go to Tools->Options->Form Designer->Device Manager

2. Click on Add…

3. Select Device Name, Platform and Form Factor, such as  ’Moto360‘, ‘Android‘ and ‘Watch

4. Load a custom Device Background graphic (this should be a png)

5. Select at least one Orientation, such as Portrait

6. Define the Screen Upper Left Corner points and the Screen Size 

7. Go to View->Multi-Device Preview to bring up the Multi-Device Preview

8. Select Moto360 from Available Previews




 XE8 Trial


posted @ Thu, 14 May 2015 20:39:50 +0000 by sarinadupont

Server Response from: BLOGS1