You are browsing the archive for Delphi.

Profile photo of marc

by marc

Hydra 4 and Oxygene January 2012 Releases

February 1, 2012 in .NET, Android, ASP.NET, Cooper, Delphi, Elements, Hydra, Java, Oxygene, Visual Studio, Windows, Windows Phone

We’re hitting the ground running for 2012 and finished January with the first two product releases of the year.

Hydra 4

Hydra 4 is a major new release for our .NET/Delphi cross-platform product, and one we’re very excited about. Hydra has been at version 3 for a while now and seen mostly incremental changes, but with version 4 we’re adding three major new features/platforms to the mix:

  • Support for 64-bit Delphi Host Applications and Plugins
  • Support for FireMonkey Host Applications and Plugins
  • Support for hosting Silverlight-based Plugins

Compiling true 64-bit Windows applications has been on the wish-list for Delphi developers for a long time, and Delphi XE2 finally provided the elusive support, and Hydra has been updated to match. This makes it easier to build applications that use large amounts of memory, can interact with .NET plugins in 64-bit space, or simply run more natively on the 64-bit Windows systems that are standard these days.

FireMonkey is Embarcadero’s new framework for creating rich “HD” or 3D graphical user interfaces in Delphi, and it is destined to supersede the VCL sooner or later. Unfortunately, Embarcadero does not let applications mix FireMonkey (FMX) and VCL by default — but that is no reason to jump ship to FireMonkey and discard all your existing VCL code. Hydra adds FireMonkey to its list of platforms supported by plugins and lets you seamlessly mix new FireMonkey UI alongside existing VCL code or even among WinForms and WPF. And FireMonkey host support lets you create new FMX applications and integrate existing VCL (or WinForms and WPF) code and UI into them, as well.

Finally, there’s Silverlight, Microsoft’s platform for rich web controls and (more prominently, as of recent) Windows Phone 7. Silverlight is based on the same concepts as .NET but uses a smaller and a tad more limited runtime — in exchange it can run in Browsers on Windows and Mac, as well as on Microsoft’s new phone platform. With Hydra 4, Silverlight can now also run in your Delphi (or .NET) based host applications, alongside other plugins. This allows you to easily share code and visual elements between your web application and your desktop app, or between your phone and your desktop.

We think Hydra 4 will be an essential tool for the modern Delphi developer — whether to add .NET to your Delphi projects or to add FireMonkey.

Hydra 4 is a free update to all users with an active subscription and available for immediate download. If your subscription expired before January 27, you can renew now for $249 to get access to Hydra 4; the price for new users is $499, including on year of free updates (and we do have more exciting stuff planned for Hydra in 2012!). Of course Hydra 4 is also included in the Suite Subscriptions for both .NET and Delphi.

Oxygene — January 2012 Release

Last November, we shipped a major new release of Oxygene, introducing the brand new Oxygene for Java as second platform for everyone’s favorite modern Object Pascal.

After skipping the holidays, we’re back to our monthly release cycle, and the January 2012 release kicks the year off with a large range of fixes and enhancements for both .NET and Java/Android developers. Altogether, the change log contains over 170 improvements.

The new Oxygene build is a free update for all customers with an active subscription, including all users of Prism XE2 and RAD Studio XE2.

For those of you using Oxygene for both .NET and Java, the update (like all future updates) is a combined installer — it will automatically detect if you have both editions of Oxygene and update both.

Get Em While They’re Hot

Head over to our trials download page at now to give Hydra 4 or Oxygene a spin. Or if you’re already a customer, visit the downloads page on your customer portal to get the latest versions.

Oxygene and Hydra go great together by the way. If you’re a Delphi-only developer right now but thinking about adding .NET code to your application, Hydra makes that easy, and Oxygene lets you keep using the familiar Object Pascal language, even for your .NET work.

CodeRage 6 – Data Abstract: Cross-platform Database Applications

October 25, 2011 in Data Abstract, Delphi, Mac, Windows

Miss my CodeRage 6 session on Cross-platform Database Applications with Data Abstract and Delphi XE2? Not to fret, you can watch it here.

It shows how to use Data Abstract with Delphi XE 2 and FireMonkey live bindings to create a cross platform application and deploy to the Mac. Also outlines some of the benefits of Data Abstract, including DA SQL, business rule scripting, Relativity Server and the new Data Abstract Server Explorer.

I’ve used the YouTube annotations to let you jump to just the parts you want to see. Turn on annotations if you don’t see them.

Profile photo of marc

by marc

RemObjects SDK and Data Abstract for JavaScript

October 7, 2011 in .NET, Data Abstract, Delphi, JavaScript, Oxygene, Visual Studio, Xcode

Today we are shipping the first beta builds of RemObjects SDK and Data Abstract with our new JavaScript client support. This beta is available at for all users with an active subscription, and we are planning to ship this feature officially in the upcoming Winter release next month.

This blog post aims at giving you a quick overview into what’s there and how to use it.

RemObjects SDK and Data Abstract for JavaScript is essentially the fourth client platform for RO/DA that we have implemented, and constitutes a fully native JavaScript implementation of our RO/DA client library – with everything you need to talk to RO or DA servers directly from JavaScript-based clients. The main focus right now is on web clients (i.e. clients running locally in a browser), but RODA/JS should also be usable from any other JavaScript based platform, such as Windows 8’s Metro, cough WebOS cough, and the like.

RODA/JS is not a separate product; rather, it ships in the box with all three of our existing server platforms: RODA/.NET, RODA/Delphi and Relativity Server.

In most cases, you will want to add the ability to expose a scripting client right from inside the regular RO/DA server you are building, and we have created components that make this really easy: Both RODA/.NET and RODA/Delphi have gained (TRO)JavaScriptHttpDispatcher and (TDA)JavaScriptHttpDispatcher components that you can simply drop into your project and hook up to your server channels. These components embed and automatically serve the core RODA/JS script files, and can also serve any custom files (scripts and HTML/CSS/Images) that you created to implement your JavaScript client (from a folder or from resources embedded in your server app).

With that done, you can simply point your browser to a subpath of your server’s URL, such as http://localhost:8099/js to access your web app.

TROJavaScriptHttpDispatcher in Delphi

The screenshot above shows the RO/Delphi MegaDemo, but a similar component is available for DA and on .NET, and all MegaDemos and DA Sample Servers have been extended to already expose sample JavaScript clients.

If you run the server and point your browser to it, it will look something like this (not about to win any design awards, but it works ;) ).

MegaDemo JavaScript Client in Action

What does the source look like? Aside from the HTML that defines what we see, there are three script files included:

<script type="text/javascript" src="RemObjectsSDK.js"></script>
<script type="text/javascript" src="MegaDemoLibrary_intf.js"></script>
<script type="text/javascript" src="script.js"></script>

The first is the core RO/JS library – automatically served by the JavaScriptHttpDispatcher component. The second is the Interface file for our server’s RODL – more on that below. Lastly, scripts.js contains the code we custom-wrote to implement our client. Let’s look at that in more detail:

First, we create our service and related components (I’m shortening the code a bit for the purpose of this post, if you look at the real sample, you’ll see it will optionally choose between JSON and BinMessage, etc):

var Service;
function createService() 
    var svcUrl = "http://" + + "/bin";
    Service = new MegaDemoService(new RemObjects.SDK.HTTPClientChannel(svcUrl),
    new RemObjects.SDK.BinMessage());

Next, let’s look at how we call Sum():

function BeginSumMethod() 
    var A = document.getElementById("editA").value;
    var B = document.getElementById("editB").value;
    Service.Sum(A, B, 
                    function SuccessSumMethod(result) 
                        AddLineToLog('Result is ' + result);
                    function ErrorSumMethod(msg, ex) 
                        if (ex) {
                            AddLineToLog(" Error: " + ex);
                    } else {

As you see, JavaScript is big on asynchronicity. Instead of calling Sum() and getting back a value, Sum runs asynchronously, and we provide a callback that gets executed when the result was received (and a second callback that gets called for any errors or exceptions).

To generate Interface files for your custom RODLs (such as MegaDemoLibrary_intf.js in the sample above), both Service Builder (Windows) and rodl2objc (Mac) have been expanded with an extra option to generate .js files. Simply open your RODL and save the Intf.js, as you already know how to do for all the other languages we support:

rodl2code with JS

(As you can see, rodl2objc has also received a bit of an interface facelift ;) )

That’s RemObjects SDK for JavaScript, for talking to custom Web Services. Next, let’s look at Data Abstract.

Like with RO, making a DA server accessible from JavaScript is as easy as adding the dispatcher and (optionally) some custom script or HTML files. Here’s what the JavaScript sample for our PCTrade Sample Servers looks like (both for .NET and Delphi):

PCTrade Sample for JavaScript

On the left, there’s list of all the tables, dynamically created by looking at the schema; once a table is selected, it shows a grid on the right. For this sample, we’re using a jQuery grid, but there’s nothing that inherently ties Data Abstract to jQuery or any other JavaScript framework – you get access to the raw data via a table object and can work with it any way you please. Of course, we cannot only show data, but also maintain updates and apply them back to the server.

Let’s look at the code again:

<script src="RemObjectsSDK.js" type="text/javascript"></script>
<script src="DataAbstract.js" type="text/javascript"></script>
<script src="DataAbstract4_Intf.js" type="text/javascript"></script>
<script src="/js/jquery/jquery-1.4.4.js" type="text/javascript"></script>
<script src="/js/jquery/js/grid.locale-en.js" type="text/javascript"></script>
<script src="/js/jquery/js/jquery.jqGrid.min.js" type="text/javascript"></script>
<script src="DataAbstractjQGrid.js" type="text/javascript"></script>

In addition to the core three RO/DA files (all of which are served by default by Data Abstract’s version of the JavaScriptHttpDispatcher), we include a few jQuery files, as well as a DA-specific helper file for jQGrid that we provide for your convenience. Once again, using jQGrid is just an implementation choice for this sample (much like using QuantumGrid would be for a Delphi app).

Other than that, all the application-specific script in this sample is in the main HTML file.

For example, here is how we set up the RemoteDataAdapter:

var Channel = new RemObjects.SDK.HTTPClientChannel("http://" + + "/JSON");
var Message = new RemObjects.SDK.JSONMessage();
var Service = new RemObjects.SDK.RemoteService(Channel, Message, "DASampleService");
var daService = new DataAbstractService(Service);
var loginService = new RemObjects.SDK.RemoteService(Channel, Message, "LoginService");
var rda = new RemObjects.DataAbstract.RemoteDataAdapter(Service, loginService, RemObjects.DataAbstract.Bin2DataStreamer);

And here is how we fetch data for a table (and show it using the jQGrid helper):

rda.getData(Tables[CurrentTable], function() {
                GridView = new RemObjects.DataAbstract
                    .Views.JQGridView(Tables[CurrentTable], "#list", "#pager");
        function(msg, e) {
            if (e) {alert(e)}
            else alert(msg.getErrorMessage());

If you’re familiar with RO and DA, you will already see that the classes are very similar to what you know. We have client channels, messages, remote services and a remote data adapter.

Relativity Server now also optionally exposes the required JavaScript files (including full Intf.js files for its admin API) as well as a JSON message. All you need to do to activate this is to check the Enable JavaScript Publishing option in Server Explorer:

Server Explorer for Mac

If the option is grayed out, your Relativity Server does not support JavaScript yet; if the option is not available, you need a newer version of Server Explorer for Mac.

A Word about Cross-Domain Data Access

You might be asking: why does the JavaScript need to be served by the RO/DA server? Can’t I just put it on my website? Technically, you could, but there’s a limitation on most browsers that – for security reasons – won’t just let JavaScript connect to different servers willy-nilly. So if you’re opening a website from, the browser won’t let the JavaScript on that site send requests to – unless at least some of the scripts originate from that server. So you can embed JavaScript code in your website and have it talk to your RO/DA server on a different domain or port, but you must at least reference the RemObjectsSDK.js and/or DataAbstract.js files from the RO/DA server to let the browser know that it’s ok to connect there.

This limitation might not apply when using JavaScript on other non-web platforms, for example on Metro (we haven’t tested that yet) or application platforms such as Titanium. It’s a limitation of what the browser lets you do, not a limitation of our client library.


Our new native JavaScript client libraries open up RO and DA servers to a wide variety of new client platforms, with rich browser-based apps only being one of many possibilities.

We have a good six weeks of beta cycle left before this feature ships, and we hope you’ll give the beta builds a try and let us know any feedback you have. Head over to now to get started.


Profile photo of marc

by marc

Announcing the RemObjects Software “Fall 2011” Releases

September 30, 2011 in .NET, Cocoa, Data Abstract, Delphi, Hydra, iOS, Mac, Oxygene, Relativity, RemObjects, Visual Studio, Windows, Xcode

Dear Users,

We are happy to announce the immediate availability of the “Fall 2011” releases of our library products, including Data Abstract and RemObjects SDK for all three platforms, Hydra, Internet Pack, RemObjects Script and Pascal Script.

The new releases focus mainly on quality, with hundreds of fixes and small enhancements throughout the product – we have improved project templates, thoroughly reworked the samples and addressed lots and lots of outstanding issues across all platforms.

But that has not stopped us from shipping some significant new features, as well.

Full Support for Delphi XE2

The probably most significant change is full support for Embarcadero’s new Delphi XE2. XE2 brings a lot of changes to the Delphi platform, and we are fully committed to supporting Delphi developers. In the “Fall 2011” release, RemObjects SDK and Data Abstract both add support for creating 64-bit Windows applications and creating 32-bit Mac OS X Applications, the two new platforms being supported by Delphi XE. Data Abstract features all new templates for FireMonkey and has been integrated with the new Live Bindings feature for both FireMonkey and VCL.
Hydra has also been updated with basic XE2 support (and we have exciting plans for features around FireMonkey for the next major release, more on that below).

Data Abstract Improvements

  • Data Abstract for .NET has been improved with support for additional DA LINQ and DA SQL constructs, such as GROUP BY support and aggregate functions.

  • DA SQL queries are now able to return updateable data tables without the client knowing the involved table name(s) beforehand – a change that has let us implement full data editing support in Server Explorer for Mac.

  • Relativity Server has been enhanced to provide a self-hosted copy of our “PCTrade Sample” Domain, and all samples have been updated to optionally talk to Relativity Server instead of the standalone sample servers provided with each platform.

  • Data Abstract for Xcode has gained support for Cached Calculated Fields, a feature driven by our own needs using DA in internal applications here at RemObjects, that can provide a significantly performance boost to your apps.

  • Data Abstract (and RemObjects SDK) for Xcode have also been made fully compatible with the new Automated Reference Counting (ARC) feature that is coming to Objective-C with Xcode 4.2.

  • Server Explorer for Mac has also made great strides since first hitting the App Store in May and is turning into a versatile tool for Relativity and DB admins independently of Data Abstract. Server Explorer is available as part of Data Abstract for Xcode, and also standalone on the Mac App Store for users of DA/.NET and DA/Delphi and non-DA OData developers.

What’s Next?

As mentioned above, the “Fall 2011” mainly focuses on quality improvements and minor features, but that does not mean our teams have been sitting still where major new features are concerned.

  • Work is almost completed on our native JavaScript clients for RemObjects SDK and Data Abstract, and initial feedback is that it will be “impressive”. We are planning to have a beta with JavaScript available to all active customers within the next couple of weeks and ship the final JavaScript support in the “Winter 2011” release. RODA/JS will be available as part of all three of our server platforms: RODA/.NET, RODA/Delphi and Relativity Server, at no extra charge.

  • We’ve also been working hard on script debugging support for Data Abstract and Relativity Server, and the next release of Server Explorer will include a full graphical remote script debugger to help you write and debug JavaScript Business Rules in Relativity Server.

  • Since we introduced Server Explorer for the Mac, the tool has become a core part of how we work with Data Abstract and Relativity Servers, and the DA/.NET team is working on bringing the same experience to Windows, replacing the aging Schema Modeler with our all new Server Explorer for Windows. We have set no deadlines for DASM7/Win as we want the tool to be as good as we can make it, but we expect to have a usable pre-release to show before the end of the year.

  • On the Hydra front, our next “Winter 2011” release will be a major one, with Hydra 4 introducing two new visual plugin platforms to the mix: FireMonkey and Silverlight. With that, Hydra 4 will let you use VCL, FireMonkey, WinForms, WPF and Silverlight within a single app.

Remember that as always, these and other future enhancements will ship at no extra charge to customers with an active product subscription, and pre-release beta and gamma builds will be available to all active customers, as well.

So whether you’re excited about XE2 support and the other features and enhancements we ship this week or just want to get ready for the good stuff that’s still to come later this year – make sure your subscription is up to date so you don’t miss out!

Get it Now!

As always, the new products are available to licensed users on our Customer Portal; Free 30-day Trial versions are also available on our Trial Downloads page.

To purchase or to renew your existing subscription, visit our secure online shop at

Also remember that you can expand your platforms at any time, simply by renewing to the new platform combo. For example, if you currently own Data Abstract for .NET, add DA/Xcode to the mix and start developing iPhone and iPad apps, simply by renewing “Data Abstract for .NET and Xcode”.


Profile photo of marc

by marc

Thoughts on Windows 8 and “Metro”

September 17, 2011 in .NET, Data Abstract, Delphi, Elements, non-tech, Oxygene, Platforms, RemObjects, Visual Studio, Windows

I just got back home from 360iDev in Denver, one of the best third party conferences on iOS development.

In parallel, another big conference has been going on in Anaheim, introducing big and significant changes to a completely different platform. I’m talking of course about //build/. As you probably heard, if you’re not living under a rock, Microsoft announced both Windows 8 and – more interesting to us as developers – Visual Studio 11, and has made preview releases of both products available, as well.

The good (and unexpected) news is that all the doomsaying about .NET has proven to be false; if anything, Windows 8 strengthens .NET as one of three ways to build high quality apps for its new Metro application platform. It does so by essentially making .NET, C++ and HTML5+JavaScript equivalent tools that can use the same APIs to create apps. Given the choice of those three, what would you choose? Clearly, .NET is the winner here.

XAML, integral part of both WPF and Silverlight in the past, has been promoted to the default UI paradigm for “modern apps”; it is interesting to see that (a) Microsoft is dropping the WPF nomenclature and talking about XAML itself and (b) making XAML UI also accessible to non-managed development using C++. The new UI layer that lets you build Metro apps is backed by WinRT, a managed class library (and subset of the full .NET framework), and together Metro and WinRT are presented as the way forward for building what Microsoft, literally, called “modern apps”. Classic Win32/Win64-based applications are still supported, but relegated to the “old” Windows desktop. It also seems (although Microsoft has not been completely precise in talking about this, so there is still some discussion and interpretation going on) that the Win32 model will not be supported at all on ARM based Windows 8 slates (i.e. not only will x86/x64-built applications not run on ARM devices, which seems obvious; no, there will most likely also not be the option to recompile classic Win32 apps for ARM. To run on ARM systems (and Microsoft is making it clear that they expect all/most tablets shipping with Windows 8 to be ARM based), the new Metro/WinRT APIs will need to be used.

It sounds like this seems to spell the end of traditional “native” Win32 development tools, at least for “modern” Windows applications.

Metro itself looks like an impressive and ambitions “reimagination” of Windows, indeed. Of course only time will tell how successful it will be and how well it will run (in my first attempts running the Windows 8 Developer Preview in VMware Fusion, it certainly feels awkward and clunky in places, and unnavigatable without touch in others), but IMHO one must applaud Microsoft for taking such a bold step.

For developers, creating apps for Metro will be a paradigm shift, much akin to targeting a completely different platform. In fact, watching the excellent Eight Traits of Great Metro Apps presentation, a lot of the purposeful “limitations” of the development remind me of iOS: the way application backgrounding is handled (your app will be killed as it gets off screen) or how Windows Push Notifications will need to be used to give the appearance of non-running applications staying live, updating their tile and providing notifications.

This goes to show, I think, how important it is to develop applications with platform-appropriate tools, not one-size-fits-all solutions. I’ve made the argument before that anyone trying to use Win32-rooted tools to create applications, say, for Mac or iOS is doomed to fail and produce sub-par results. The same, I believe, will now apply to using Win32-based tools to create Windows 8 apps: Your applications will look out of place, and/or be relegated to the legacy desktop.

In the same vain, it is great and refreshing to see Microsoft talk about and stress how important good design, a quality user experience and conformance to the Metro design paradigm is (same video). They really copied the right pages from the Apple playbook here.

So What about Our Tools?

Windows and .NET are a very important platform for us here at RemObjects, and that continues to be the case going forward. The teams here are already hard at work at providing support for VS11, WinRT and Metro, based on previous access we had to internal betas as well as of course the Developer Preview that is now available via MSDN to everyone.

Data Abstract (and RemObjects SDK) will be integrated into Visual Studio 11 soon, and will let you build Metro clients (something which is especially important since the client data access story on Metro/WinRT seems to be pretty thin, otherwise). We’re not forgetting Hydra, either.

And Oxygene will, of course, let you create Metro/WinRT applications, allowing you to build native applications with lots of shared Object Pascal code for Windows Phone 7, Android and Metro – next to, of course, regular Windows and cross-platform apps with .NET, Mono and Java.

I don’t want to promise exact timelines, but we’ll let you know more and will have beta bits for customers to play with, Real Soon™.

Exciting Times Ahead

As most of you know, I’m mostly a “Mac and iOS guy” and have not been a big fan of the Microsoft platform for a while. But what I’m seeing here looks impressive, and while I’m not contemplating to switch <g>, real competition is good for everyone, and it is great to see a new quality platform coming out of Microsoft, and I believe this will be a great opportunity (and challenge) for Windows developers. The next couple of years will be very exciting, as far as development platforms go!


Profile photo of marc

by marc

Gamma Builds of Data Abstract and RemObjects SDK with Delphi XE2 Support Available Now.

September 2, 2011 in Data Abstract, Delphi, Mac, short, Windows

As promised in my previous post, new gamma builds for Data Abstract and related products are available with full support for Delphi XE2, including Win64 and Mac OS X.

These are not “gamma” builds from the branch we are working on for our upcoming Fall 2011 release due later this month; these builds are feature complete and considered “stable”, but they have not yet gone thru the full range of testing that our final releases go thru, so use them at your own risk.

To get the builds, head over to Like all of our beta programs, these builds are available to any customer with an active subscription. Please use the private ROFX beta forum on RemObjects Connect to discuss these builds and provide feedback.

Enjoy Delphi XE2!

Profile photo of marc

by marc

Delphi XE2 Support

August 30, 2011 in Data Abstract, Delphi, Hydra, Mac, Windows

I want to take a few moments to talk about support for the upcoming Delphi XE2 in our “for Delphi” products. As most of you have probably heard by now, Delphi XE2 is one of the more exciting releases for the development tool in the past years, adding a lot of new functionality. For the purpose of our products, there’s really four areas of interest that are new in XE2:

  • Platform support for 64-bit Windows
  • Platform support for 32-bit Mac OS X
  • Live Bindings
  • FireMonkey

Our products, especially Data Abstract and the underlying RemObjects SDK are mostly non-visual, so the new platform support is probably the most interesting aspect for us.

As you know, we have long supported Win64 and (to a lesser degree) Mac OS X via the open source Free Pascal compiler, so we have been in good shape for supporting these two new targets with Delphi XE as well. So it goes without saying that we’ll be fully supporting RO and DA on these three platforms, starting with the next release, both for creating clients and servers.

64-bit Windows will be a default part of new VCL-based Data Abstract projects created thru our wizards; and we will also have new templates to get going with FireMonkey-based DA clients on Windows and Mac.

Live Bindings are another interesting area for Data Abstract, as they make it a lot easier to connect visual controls to database content without relying on separate “TDB*” components, as used to be necessary. Data Abstract will include full support for Live Bindings as well.

As already mentioned above, RO/DA are pretty much non-UI libraries, so they work regardless of the actual UI layer and will function in FireMonkey and VCL applications alike. Of course we do have some visual elements in DA, such as our standard Reconcile Dialogs, and these areas have been abstracted to properly provide different versions of the dialogs for VCL vs. FireMonkey (and of course you have always been able to add your own Reconcile UI yourself, and you can still do that).

FireMonkey is a lot more interesting for Hydra, and as you might have seen in Alex’s blog post a few days back, we have been hard at work to fully integrate FireMonkey into Hydra as a UI platform equal to VCL, WinForms and WPF, so that you will be able to seamlessly mix all four of these UI technologies with the upcoming Hydra 4 release (in addition to a fifth UI platform for plugins: Silverlight). Hydra will be supported on 32-bit and 64-bit Windows.


The important question you have of course, is: when can you get your hand on this stuff? The answer is: ASAP.

We have been shipping beta builds with (secret) XE2 support for a while now, so people who have been participating in the field test of Delphi XE2 and installed our betas could already use RO/DA with the new technologies.

As of the day Delphi XE2 RTMs, we are planning to have a fresh beta build up that will be off our “stable” branch and can be used with XE2. This build will not contain binaries (to ship XE2 binaries, we need to integrate the final XE2 into your build system, which we cannot do until it is final ;), but it will include all the files you need to build and install the XE2 design time packages from source.

Later in September, probably somewhere in the early second half of the month, we will ship our official “Fall 2011” releases of RO and DA, which will contain all the XE2 support outlined above, including pre-compiled binaries, and we will also have a new Trial version that supports XE2.

For Hydra, we will stay in beta a little wile longer; we expect to have a “usable beta” build with FireMonkey support for you within September.

Remember: Our betas are accessible to all customers with an active subscription, so to get going with RO/DA on Delphi XE2 right away, just head over to If your subscription has lapsed, there’s no time like the present to go and renew now to make sure you have access to the betas and will get the final products with XE2 support as soon as possible.

Hydra and FireMonkey – Best Friends Forever

August 18, 2011 in .NET, Delphi, Elements, Hydra, Windows

As you have probably alrady heard, in the upcoming release of Delphi XE2, Embarcadero will introduce a new cross-platform GPU powered GUI framework called FireMonkey. The new framework is similar in concept to .NET’s WPF, and builds on the former VGScene/DXScene components to let you to build applications with both 2D and 3D elements, transforms and animations.

FireMonkey is not an evolution of the VCL, nor does it replace it. The VCL will still be incldued with Delphi, with FireMonkey being an alterative option for UI development. But while the VCL remains for Windows only, FireMonkey will allow you to create GUI applications for both Windows (32 and 64 bit) and Mac OS X.

Since FireMonkey is a cross-platform framework, it’s not bound to Windows and it doesn’t directly use things like the Windows message loop or handles. Being a GPU powered framework, FireMonkey uses Direct2D/Direct3D or OpenGL to render GUI, meaning that by default, FireMonkey and the VCL will not get along well, and you won’t be able to, say, add a FireMonkey control to a VCL application or vice versa, or even share FireMonkey and VCL forms within the same application. Which is a shame, really, if you have an exisiting Delphi app that you want to extend with some nice FireMonkey graphics, for example.

Enter Hydra

Traditionally, Hydra has served the purpose of letting you mix Delphi VCL applications with UI (and non-UI) written .NET (using either WinForms or WPF).

So will Hydra support FireMonkey, as well? Yes it will. The Hydra team is currently working on providing full support for FireMonkey plugins on both .NET and Delphi hosts. With this new feature in Hydra, you will be able to use both visual and non-visual plugins built with FireMonkey in the same way you can currently use VCL or .NET plugins.

To show you a few examples:

FireMonkey in the Delphi VCL

Hydra will provide the ability to host FireMonkey plugins inside the VCL:

FireMonkey in the VCL

FireMonkey in .NET WinForms

The following screenshot shows a FireMonkey plugin running embedded in a WinForms-based .NET application:

FireMonkey in WinForms

WPF in FireMonkey

Or you can even show a WPF plugin within a FireMonkey host application:

WPF in FireMonkey

Of course, these are just three examples, all the other obvious combinations will work as well (FireMonkey in a WPF app, VCL or WinForms in a FireMonkey app).

Find out More

FireMonkey support in Hydra will ship soon™ after Delphi XE2 is generally available, and will be a free update to any customer with an active Hydra subscription. (Current Hydra users will also be able to access beta builds with FireMonkey support when XE2 is out.)

Find out more about Hydra at

Profile photo of Alex

by Alex

Changes in the Data Abstract Samples Suite

August 17, 2011 in .NET, Data Abstract, Delphi, iOS, Mac, Windows, Xcode

Before the next upcoming release, I would like to highlight several changes concerning our Data Abstract samples suite.

Provided sample domain with the Relativity Server:

With the next release, we will provide Relativity Server with a new sample domain named PCTrade Sample that will contain a single schema called PCTrade. This schema will use the PCTrade for SQLite connection. The default login and password for this domain are Data and Relativity, respectively.

With this sample domain, Relativity Server can now be used as the server part for most of our DA samples in addition to the existing DASampleServer.

For the Xcode samples, you can easily choose the server you want to connect to:

For the .NET & Delphi samples you will need to set the flag value to True in the sample code as shown in the picture below:

Please note that several .NET samples, like Business Processor Sample and Refresh Update Data Sample, do not support working with Relativity since they depend on server logic implementation.

New Login service for the DASample server:

From the beginning, our samples had a virtual login implementation used only for the identification of clients and their platforms. For the next release, we have added a new secure DataService and LoginService to the DASample server. In order to maintain compatibility, we left the existing DASampleService unsecure. So if you try to build a client using that service, you will not need a login. But we added the new DataService on the top of the DASampleService, and made it secure. Thus, if you request that service, you need to login first.

The New Project Wizard for DA/Delphi

June 28, 2011 in Data Abstract, Delphi, Windows

Today, I want to show you the new Template Wizard in Data Abstract for Delphi.

Notice the VCL Application icon under the Data Abstract project type. This will launch the new Template Wizard. The template wizard includes a number of new options that were previously not available.

RemObjects Data Abstract for Delphi Template Wizard

The first project type creates a Client for Relativity server. If you are not familiar with Relativity server, it is a pre-built, reusable server recently introduced with Data Abstract. It serves as your middle-tier, making data publishing easy, so you can focus on your client application development.

If you have an existing custom Data Abstract server, you will want to choose the second option to create a new client. This is great when you want to add a new, different client to your existing architecture, if you are connecting to a server created by someone else, or with a different edition of Data Abstract.
Both of these two options obtain the schema information from the middle-tier instead of the database.

The third option is similar to the old wizard. It will create a new custom server and client at the same time. You just have to specify a connection to a database and the schema will be built based on that database, and then your client and server are built based on that schema.

This last option is an interesting twist on a Data Abstract application. Instead of having a separate middle-tier, it creates a single monolithic client that contains the schema and database connectivity. This effectively creates a Client/Server application, but lets you take advantage of the powerful and familiar features of Data Abstract, including schemas.

Let me show you how to create a client for Relativity server. If your Relativity server is running on your local network, the wizard can discover it via ZeroConf. If your server is not on the local network, just specify the Relativity URL. If you are using AES encryption, you also have to specify the password.

Now select the domain. Each domain is an individual Data Abstract server instance within the single Relativity server. If the domain you want is not already defined, you can click the Start Admin Tool to launch the Data Abstract Administration tool and define the domains and schemas you want.

You also need to provide the username and password necessary for connecting to the domain, because all the schema information is obtained via the connection to the Relativity server. This is great if you are connecting to a server that is hosted elsewhere and you wouldn’t otherwise have access to the database. The default Relativity data username & password is Data & Relativity.

Select Relativity Domain

Once you connect to the domain, the wizard enumerates the schemas and tables. Any tables selected will have strongly typed Data Tables created in the client application.

Relativity select Schema and Tables

You can change your Data Streamer for Data Transfer. It is recommended that you stick with the Bin2DataStreamer though.


Finally, give your project a name and optionally specify a different location for the project.

Project name and path

When the wizard finishes, the project will open in Delphi ready for you to finish your application. The operation of the other wizards is pretty similar. I encourage you to download the latest update of Data Abstract for Delphi and try them out.

If you would like to see the Relativity client completed, check out the full video on the Data Abstract channel in RemObjects TV or watch it on YouTube.