If one uses the obvious Password=xxx;User Id=Admin you will get an error “Workgroup Information file missing or file is in use by another user”.

The ADOConnection will return an active connection is using the following connection string but in Delphi 2007 I am still getting an error on trying to read the file “Could not decrypt file”.

So here is the Connection String which will open the connection successfully in Read Only mode:

Provider:=Microsoft.Jet.OLEDB.4.0;Data Source=C:\temp\MyExcel.xls;Mode=Read;Extended Properties=Excel 8.0;Jet OLEDB:Database Password="xxx";

It appears that “Could not decrypt file” error is due to a well known limitation of the Jet OLEDB 4.0 engine in that it always returns this error on trying to read a password protected Excel file even if passwords are known.

The hack around this is to open the file in Excel first in full read/write mode BEFORE opening the TADOConnection – just opening it in READ ONLY mode in Excel WILL NOT work!

This is not only an issue in Delphi but in any application that uses Jet 4.0 OLEDB engine.

Of course, another solution is to use COM OLE automation such as:

• CreateOLEObject method – see here

Excel 2007 and higher files (.xlsx):

If you are dealing with .xlsx Excel 2007 or later files, you cannot use the Jet engine, but you can use the ACE OLEDB driver:

• ACE 32bit OLEDB driver if 32bit Office is installed:
• Provider := Microsoft.ACE.OLEDB.12.0;Data Source="C:\temp\MyExcel.xlsx";Extended Properties="Excel 12.0 Xml;HDR=YES;“;Jet OLEDB:Database Password=”";
•  ACE 64bit OLEDB driver if 64bit Office installed and 64bit ACE installed:
• Provider := Microsoft.ACE.OLEDB.14.0;Data Source="C:\temp\MyExcel.xlsx";Extended Properties="Excel 12.0 Xml;HDR=YES;“;Jet OLEDB:Database Password=”";
• NB. YES you read correctly, that is Jet OLEDB:Database Password=”"; and NOT ACE OLEDB:Database Password=”"; !!! AND strangely enough, you can connect to a password protected file without supplying a password at all BUT, whether or not you supply a password, the password protected Excel file MUST be already open in full edit mode within Excel first!
• NB. to install ACE 64bit on a machine which already has ACE 32bit installed, use command line: AccessDatabaseEngine_X64.exe /passive
• to connect to Excel 97-2003 .xls via ACE use Extended Properties=”Excel 8.0;HDR=YES;”
• to connect to Excel 2007-2010 .xlsx via ACE use Extended Properties=”Excel 12.0 Xml;HDR=YES;”
• to connect to Excel 2007-2010 .xlsm via ACE use Extended Properties=”Excel 12.0 Macro;HDR=YES;”
• to connect to Excel 2007-2010 .xlsb via ACE use Extended Properties=”Excel 12.0;HDR=YES;”
• if you get the error “could not find installable ISAM”, you have probably made an error with the connection string.
• unfortunately, if the Excel file is password protected to read, you will get an error “External table is not in the expected format” unless it is already opened in Excel and user has edit rights to the spreadsheet! So we have the same old situation as with the Jet OLEDB provider!
• and don’t bother trying Password=”xxx”;User ID=Admin; as additional parameters, because as soon as you add a value for password, you get the same old Jet issue of “The workgroup information file is missing or opened exclusively by another user”.

Delphi Object Pascal or C++ generated DataSnap middle tier data servers which run on a Windows server and allows the following thin clients to connect to it:

• Delphi Object Pascal or C++ VCL WinForms clients compiled for either Win32 or Win64
• Delphi Object Pascal FireMonkey compiled for native client application for any of the following platforms:
• Win64
• Win32
• Mac OS X
• iOS
• and in 2012, Linux and Java for Android
• via Mobile Connectors:
• Eclipse compiled java client for Android
• XCode compiled iOS client for iPad, iPhone
• Blackberry client
• Windows Phone 7 client
• isapi.dll web client hosted on a Windows web server
  
• RADPhP web application hosted on a web server (requires the DataSnap server to be a REST application)
• RADPhP mobile application packaged for mobile devices via PhoneCap
• .NET client created using Delphi Prism (REMObject’s Oxygene) Object Pascal for .NET running in MS Visual Studio
• ASP.NET web database application created using Delphi Prism (REMObject’s Oxygene) Object Pascal for .NET running in MS Visual Studio.
• Java client created using REMObject’s Cooper project – Object Pascal for java running in MS Visual Studio (in development)

Third party REMObjects is extending its Hydra technology to allow FireMonkey plugins to work on VCL Winforms, and vice versa, as well as WPF plugins to work in FireMonkey apps and vice versa – see here.

RADPhP web database application using MySQL database.

This post I will explore the FireMonkey aspect of Delphi XE2 a bit more deeply.

Vector-based architecture features and implications:

• Firemonkey architecture is presumably a significantly enhanced non-VCL successor to Kryukov’s KSDev vector-based VCL components including VGScene, DXScene, ImageFX and his iOS compiler, for which Embarcadero acquired the IP (apparently in Jan 2011 when further development of his VCL components was ceased, and would explain why the Delphi community was taken by surprise with the recent announcement of FireMonkey).
• allows 3D modeling with all computing work performed by the device’s GPU (thus 3D features currently will not display if remote desktop or Citrix environment)
• allows assigning data points on a 3D model which can then linked via the new LiveBindings functionality to a source data, thereby enabling live 3D charting, etc
• can import various 3D models such as 3ds or Collada, with potential to add more support later.
• full zoom in and out capability without image degradation which means controls look good even on small devices when zooming is applied
• ability to apply 3D effects and filter effects to forms or components, thus one could create a page turning effect potentially.
• a critical difference to other vector based frameworks such as Abobe Flash and Microsoft’s WPF (an XAML DirectX .NET based technology with data bindings, upon which Silverlight is built), is that Apple allows FireMonkey applications to be added to their iTunes app store and thus made available for use on iPhones and iPads (ie. it is FPC-compatible).
• when compiled to a Windows platform, it utilises Direct2D and Direct3D, when compiled to Mac OS X or iOS, it utilises OpenGL.
• it is currently designed for native applications (ie. running independently of any web browser) and not for Rich Internet Applications (RIA) within web browsers (as does Silverlight or Air), and is not specifically targetting gaming development.

FireMonkey components:

• does not use Windows messaging and thus does not play well with visual VCL components in the same application, thus avoid them, BUT one still uses TDatasource, TClientDataset, etc.
• source code included – 99% is Object Pascal code with only a small section of non-pascal GPU code
• components designed to make migration from VCL as simple as possible by keeping similar naming and properties where possible but obviously events that take Windows messaging parameters had to be changed.
• new LiveBindings functionality (which also is now on VCL) means almost any property of a control can be unidireectionally or bidirectionally linked to a source – be it a form variable or TDatasource.dataset field, or other control parameter, this also means, some properties such as position x are no longer integer but Double.
• TFmxObject = class(TComponent);
• any object can contain other components to make it versatile and very easy to create customised objects
• just drop a component onto another component and it will become a child of that component – need to take care in the IDE when dropping components onto a form!
• heavily dependent upon interfaces
• IControl handles focus, mouse and keyboard events, implemented by TControl and TControl3D
• IRoot is interface to top-level containers and is implemented by TCustomForm
• IScene is the container for 2D objects and is implemented by TForm and TCustomLayer3D
• IViewPort is the container for 3D objects (and requires a GPU), and is implemented by TForm3D and TViewPort3D
• GPU-based shading filters which can be applied to bitmaps, forms and controls to give Photoshop-like effects
• new Animation functionality which allows one to modify a property value over time and thereby create changing colors, changing position, etc.
• new Styles is a CSS-like functionality which allows dynamic skinning with ability to save, load and modify at run time to dramatically alter the appearance of the application.
• new StyleBook is a container for styles and provided styles include Win7, MacOSX, etc, but of course one can create their own styles.

Live Bindings:

• available in VCL as well as FireMonkey and in effect makes ALL components and their properties data aware if you wish – very versatile and quite different to VCL’s data-aware approach which is not available in FireMonkey.
• can specifiy unidirectional or bi-directional links which have read/write capability via use of expressions
• a binding consists of 4 aspects:
• source object – this may be a TDatasource.dataset.field or a form variable or component
• source expression – a string which can be edited at runtime. For example, the name of the source property value you wish to bind to such as DisplayName if source is a TField
• control object – this is the destination object that you are binding to.
• control expression – a string which allows one to format the bound data for display, etc. and to specify the control property value which will be linked eg. label.text
• bindings are stored in TBindingsList, and also allow you to register methods available to be called from the expression strings. The expression evaluation engine also accesses the RTTI.
• one also needs to set a scope for the binding and this may be done automatically and uses TBindScope and TBindScopeDB (if linking to a TDatasource)
• instead of TDBNavigator, there is a TBindNavigator which links to a TBindScopeDB or a TBindScope.
• LiveBindings introduces wonderful new versatile opportunities (eg. you can bind to any component property and even to points on a 3D model) but does introduce a significant potential for runtime errors as the expression strings are no longer part of the compiler syntax mechanism, and particularly, if you change the name of a control or variable during refactoring and forget to change it within the expression, or just do a typing error, you will not get a compiler error but a potentially difficult to detect runtime error which may or may not create an exception.
• to create a LiveBinding on a form control, just click on the LiveBindings property of the control and you will have the option of creating one manually or choosing “Link to DB Field” which will automatically place the LiveBinding comonents on the form, and will display all TDatasources and their fields for you to select a field to bind to.

Cross-platform RTL support:

• TFormatSettings in SysUtils
• TOSVersion
• TZipFile in System.zip for crossplatform zip/unzip of files – now this will make life much easier!
• TLoginCredentials
• TPointF

Cross-platform debugging:

• this has been simplified – one copies the Embarcadero Platform Assistant to the target machine or virtual machine, specify port and optionally password then just run it.
• within Delphi IDE, define a remote profile specifying IP address, port and optionally password and remote paths.
• Run with Debug

Cross-platform development limitations:

• platform specific functionality obviously is not available for cross-platform compilation eg. Windows messaging (and thus the VCL), COM, menus (not available on iOS), OS API’s, MS XML transforms, etc
• whilst many GUI applications MAY be applicable for use as is across multiple platforms, the reality is that you would probably wish to have a GUI that is optimised for each platform, and this too is obviously not only possible with FireMonkey, but the best approach for many applications.
• presumably one could use compiler directives to access different API’s or to use COM for Windows compiles, or access iOS camera for iOS compiles.
• issues with Free Pascal for developing iOS apps – see here.

Current limitation issues which will almost certainly be addressed by XE3 release in late 2012:

• cannot compile to Linux, Android or Blackberry (but there are java based Datasnap client solutions for these platforms in the interim)
  
• no Windows 8 specific support as this has not yet been released by Microsoft.
• no customisable gesture support as is currently in the VCL, but usual gestures such as those on an iPad will work as they do normally without programming.
• compilation to iOS is only Object Pascal (not C++ yet) as it relies upon compilation using FreePascal (and thus certain features such as Generics, Anonymous methods are not supported), and then requires one to use Apple’s xCode IDE to do the final compile – but at least one can debug and edit the Object Pascal code within xCode and changes made within Delphi are automatically visible in xCode without having to go through the FreePascal again.
• iOS compile requirements:
• Mac Snow Leopard on an Intel Mac
• iOS SDK with developer subscription (4.2, 4.3)
• xCode 3.25 or 3.26 to do the final compile
• installed official FreePascal 2.4.4 binary required to build FPC 2.5.1
• if using virtual machine on the Mac such as VMWare Fusion, ensure you save your project to a shared folder that can be accessed by xCode
• once project saved in Delphi, use a command line utility to export to xCode files (in a subdrectory)
• then run xCode in OS X and open that project in the xCode subdirectory and compile, debug or run on a connected physical device or an emulation of the device
• your original object pascal code will be accessible, debuggable and editable within xCode!

Development machine:

• It would seem for cross-platform development, the preferred environment may be Mac OS X running Delphi within a 64bit Windows VMWare Fusion virtual machine.

• This would then allow running Apple’s xCode on the same machine and allow all debugging to be performed with the one computer.

Here are a few of the new features in XE2:

64 bit Windows compiler:

• for most Win32 projects, just select compile to Win64 and you have native 64bit Windows executable or DLLs!
• if your project uses 32-bit assumptions, then these will need to be addressed, but otherwise it should just work.
• NB. NativeInt, NativeUInt, pointers, indexes to dynamic arrays, tag properties (now nativeInt) are 64bit
• Use your same source code and project files – just select an additional platform to build for in the project window
• Use the same Windows API calls in your code, although Microsoft have renamed some (eg. SetWindowsLong is now SetWindowsLongPTR)
• Use the same Runtime Library classes and functions
• Use the same VCL components and non-visual components
• new compiler directives include Win64, CPUX64
• can only access 64bit versions of dlls, ActiveX controls, bitmaps and COM objects (eg. 64bit MS Office will only work with 64 bit exe’s and vice versa)
• Win64 now ignores register, pascal, cdecl, and stdcall, so these are ignored in 64bit compilations.
• No Extended type
• issues with assembly code, SHL and SHR

New FireMonkey GPU framework for NATIVE deployment to Win32, Win64, OSX, iOS and Android:

• 1st the bad news – to convert your existing projects, you will have to migrate all your VCL-based code and components to FireMonkey components as the two are not compatible in the same project (because it does not directly use Windows messaging like the VCL does), and instead of data-aware components as in VCL, we now have Live data bindings for all components (these are also now available in VCL)
• Now, the fantastic news:
• awesome 2D and 3D rotatable, visual forms and components with enormous potential for native GUI apps
• you can apply the Gaussian Blur filter on your form at a strength you deem appropriate when a modal form is activated in front of it
• improved animations of visual controls
• compatible with TClientDataset and DBExpress components
• NATIVE deployment as Object Pascal code to target platforms including iOS and thus satisfies Apple’s iTune apps requirements
• Create a single application and target both Windows and OS X
• the framework makes extensive use of interfaces to establish contracts, not inheritance
• it is not managed code like .NET nor does it use AIR, Silverlight, HTML5 or CSS for its functionality but native code

Enhanced DataSnap DBExpress functionality:

• DBExpress ODBC driver
• new mobile and cloud connectivity in RAD Cloud – Microsoft Azure and Amazon support
• supports https
• new Datasnap server functionality includes client connection information and management of the connection from the server with ability to limit number of requests per connection, and ability to detect connects, disconnects, and to forecfully disconnect clients.
• DataSnap clients can be created for nearly every common device natively via FireMonkey although Linux, Android and Blackberry devices currently are limited to using java Datasnap mobile connectors, while Windows Phone 7 devices are limited to using C#/Delphi Prism Datasnap mobile connectors.
• one creates an Android Datasnap client in Delphi XE2 by creating a REST application and ticking the mobile connectors option which adds a DSProxyDispatcher component which will generate project java files such as DSProxy.java which can then be imported into Eclipse IDE for packaging as an Android app.

Enhanced VCL functionality:

• the VCL is NOT being made redundant as it is needed for Windows specific applications (eg. using COM, etc) and backward compatibility
• new functionality includes option of using the incredibly versatile LiveBindings functionality (see next post on FireMonkey) and new VCLStyles which allows a different mechanism of skinning to FireMonkey as it allows the use of a vsf file to be loaded at runtime, or added to the executable in Project options application appearance section, and then allows use of TStyleEngine and TStyleManager to set styles or load from file, but these styles are not applicable to menus, popupmenus or ribbons.

New RadPHP functionality:

• rich jQuery mobile components
• Create mobile-optimized web applications and standalone apps for iOS and Android devices using RadPHP – PhoneGap wizard allows packaging your application by creating java files for import into Eclipse java IDE, selecting a target platform (eg. Android v2.2) and running in the emulator before uploading to the Android store.
• Create mobile optimized web applications that work on all types of mobile devices with elements that behave similar to native mobile apps.
• Take advantage of touch optimized layouts, user interface elements, and professional looking theming using HTML5, CSS3, and JavaScript on the client and PHP on the server in an easy-to-use and visual way that only RadPHP can offer.
• Using jQuery in RADPHP and a technology called PhoneGap, you can now package up a PHP application and deploy it as a native Android application

Very exciting times indeed!!

You can register for the Australian part of the World Tour demonstrations here – the Melbourne event is next Thursday, the 11th August 2011.

This ease of configuration from the net was one of the reasons that made Skype so popular.

It will be interesting to see what Microsoft does with it now that Google is also entering into the VOIP marketplace with its Google Voice product which uses SIP addresses (SIP technology is now in some of the new mobile phones) – Google Voice is currently only available in the US.

Sun took Microsoft to court when Microsoft tried to add proprietary extensions to Java which was owned by Sun and this ended Microsoft’s desire to use Java.

Microsoft then hired one of the architects of Delphi to come up with its own equivalent of Java – and this was the C# language which became the basis of Microsoft’s .NET technology and Windows Performance Framework (WPF) which was the .NET graphical engine for rendering user interfaces on Windows operating systems.

Microsoft then disgarded its Winforms-based development tools such as MS Visual Basic and forced VB users to migrate to VB.NET which would work alongside C# as a programming tool in the MS Visual Studio suite.

This change of direction pushed most developers to .NET, and away from native compiled Windows applications and also away from Java.

Borland responded by creating a .NET version of Delphi which has now evolved to be Delphi Prism but in the process meant it lost its way, and eventually sold Delphi to Embarcadero which is now again leveraging its power and versatility, particularly with its re-vitalised Win32 native application development which will hopefully soon also be able to create native compiled Win64, Linux and MacOS apps, but also with its relationships with RemObjects and the furthered development of Delphi Prism .NET to include ports to MacOS.

In the first decade of this millenium, the vast majority of Windows application development was targeting .NET and if you were not making .NET, companies would think twice about your product.

In 2007, Microsoft released Silverlight – a C#, .NET, WPF technology designed to compete with Adobe Flash and provide a graphical plugin environment for web browser which would run on other major operating systems including MacOS. Developers again rushed to embrace this new technology which has a lot of nice features but also a few downsides.

In late 2010, Microsoft created an uproar amongst the developer community by its apparent lack of ongoing commitment to Silverlight which although provides the richest client experience on Windows browsers, does not run on the multitude of new devices such as Android. Microsoft and Apple now seem to have abandoned .NET and Silverlight and are pursuing HTML5 and javascript technology as  the future of cross-platform web browser applications. Adobe have created their Wallaby conversion tool to allow Flash developers an easier way to migrate their work to HTML5 given that Flash developed websites are locked out of the Apple iOS devices.

see:

• http://www.amazedsaint.com/2010/10/silverlight-vs-html-5-debate-dilemma.html
• http://www.itwriting.com/blog/3127-microsoft-wrestles-with-html5-vs-silverlight-futures.html
• http://team.silverlight.net/announcement/pdc-and-silverlight/
• http://www.itwriting.com/blog/3921-where-is-microsoft-going-with-its-rich-client-api-microsoft-drops-some-clues-as-developers-fret.html
• http://andrewtokeley.net/archive/2010/09/04/when-should-you-use-silverlight.aspx

This leaves many developers wondering about the future of .NET itself when Microsoft does not actually create any major Windows applications using .NET but rather uses native compiled applications for their better performance.

For instance even though Microsoft totally revamped Office apps in 2007, they did not resort to using .NET to architect these.

Likewise, Microsoft Office is not architected with .NET and has a much better user interface than the browser webmail version which demonstrates the limitations of browser-based rich client application development.

If you follow the arguments currently flying around the web, Silverlight and .NET are just not fast enough for major enterprise-wide rich client major applications, and Winforms is still the preferred technology base for such applications.

I know where this leaves me, very happy that I did not change to .NET and abandon Delphi Win32 and its fast natively compiled Windows applications with full access to Windows API’s and memory management, with potential to have native Win64, MacOS compiled apps in the near future.

Furthermore, HTML5 web client solutions need data driven web servers, and these can be created in Delphi 32, Delphi 64, Delphi Prism .NET or Delphi PHP or C++ Builder, depending on your fancy, either with REST/JSON, SOAP/XML, REMObjects or other messaging and with either Azure, Amazon EC2 cloud, DBExpress, ADO, ADO.NET or ASP.NET data technologies, and all with the same RAD Studio programming tool.

How to manage the different SQL dialects:

• whilst sticking to ANSI-SQL 92 syntax will help, particularly with table joins, data conversion or calculation routines and simple data elements such as current date vary with each database vendor making code re-use a nightmare.
• if you ever plan in supporting multiple vendors such as MS SQL server and Oracle, then you need to consider your application design to factor this in.

How to swap between different database engines:

• DB Express may be fine for many functions, but it has limitations which are not present in Borland Database Engine (BDE), or you may wish to use ADO or other engine technology.
• unfortunately, each engine technology has different programming syntax, and indeed different non-visual Delphi components for the database connection and the TQuery component.
• furthermore, they tend to return different data types, for example DBX uses TSQLTimeStamp while BDE uses TDateTime, while BDE and ADO differ on how they determine which field is a numeric or integer field. This makes using persistent fields problematic.

On my research, there are 5 main Delphi approaches:

The traditional Delphi / MIDAS / Datasnap approach:

• see here for details on how I use this approach
• this requires maintaining separate datamodules for each database engine, and potentially separate datamodules for different vendors unless you write code to manually modify SQL statements dynamically.
• easy to visualise and TClientDatasets work as designed with persistent fields, but not so easy to maintain as you need to remember to add your modifications to each version of datamodule.

The Dimeric Virtual Database approach:

• in 2002, Dimeric Software created a database abstraction technology (VDB) for Delphi 6 to help address the above issues and add extra functionality such as database connection pooling, enhanced transaction capabilities, enhanced control over prepared queries, etc.
• it uses interfaces to abstract the Dephi components such as TDatabase, TDataset and TDatasetProvider but leaves TClientDataset unchanged.
• they support the following database engines BDE, ADO (dbGo), DBX (DataSnap), IBX (Interbase Express), ADS (Advantage database server), DBISAM, and Flash Filer 2.
• it uses a set of “Function Escapes” to convert SQL statements to vendor specific statements on the fly – ie. in your SQL statement you would use [today()] and the VDB will convert this into the vendor specific SQL command to retrieve today’s date.
• they have support for the following database vendors or dialects: MS SQL Server, Sybase, Oracle, Interbase, Informix, MySQL, Paradox, DB2, and MS Access.
• this interface approach is powerful and inexpensive ($US99) but may not be the easiest to use if you wish to use persistent fields in TClientDatasets
• see their website for more details.
• Misha Charrett utilises this technology in his CSI Distributed Application Development Framework which makes developing multi-threaded applications easier – see here. This is freely available for use but does require Delphi 2005 or higher.

RemObjects Data Abstract:

• a more expensive solution (~$US990) which will require you to replace TClientDatasets with their equivalent component as well as all the other non-visual database connection components.
• you will not be able to use persistent fields but all fields on the client side are declared in the classes which means a change in the way you approach programming.
• uses Schema to handle different database vendors
• it does allow for data push functionality
• there is no easy conversion from a legacy Delphi application.
• see here for more details.

kbmMW Development Framework:

• kbmMW is another option which may be considered and new licence for the Professional version is $US478
• they do have a free, limited functionality version without source code but only for the current version of Delphi.
• supports different database backends directly without having to write any code.
• advanced connection pooling on both client to server and server to database, caching of result sets on both client to server and server to database
• can mimic as a SOAP server, a WEB server, a AJAX server, a AMF3 server
• only the Enterprise version supports multiple messaging topologies incl. Peer 2 Peer, Hub/Spoke and Broadcast using Publish/Subscribe based messaging via multiple types of fully developer accessible and configurable  message queues
• supports client side controlled transactions, and supports transactions, even spanning multiple databases.
• supports most database vendors
• Automated datastore/database connectivity recovery on connection loss or database breakdown
• compiled as an assembly, kbmMW can be used, feature complete, from within VS.Net to develop both client and server side code
• a native PHP extension exists for both Win32 and Linux that allow direct access to a kbmMW based application server
• an application server can also be accessed from portable devices via a fully portable native C client, a Compact Framework compatible native C# client, a SOAP interface, or an XML interface (only available in Enterprise version).
• the free version “CodeGear” is available for Delphi versions 2007 and later.
• unfortunately, attempting to install this D2007 version failed with the latest Indy version installed, it presumably needs the Indy version shipped with Delphi 2007 (ie. Indy 10.1). Design package could not load as procedure entry point @Idtcpclient@TIdTCPClientCustom@SetBoundPortMin$qqrxi could not be located in IndyCore100.bpl.  The difference in the Indy source seems to be that the constant for this procedure is now TIdPort:Word instead of integer;
• this is an issue as the CSI framework requires the latest Indy version installed.

ASTA:

• ASTA is another data abstraction technology from the 1990′s
• in Nov 2010, they announced ASTA 4 with Unicode support for Delphi 2009, 2010 and XE.

I have created a page explaining the issues and the tweaks needed to get these running nicely in 64 bit Windows 7 – see here.

Most of the issues have to do with UAC and the altered location of System32 files and registry keys.

Before you install any of these, make sure the least you do is change the default install directory of Delphi to somewhere other than C:\Program Files path!

If you are just wanting to run your Delphi 6 or 7 apps on 32 bit Windows Vista or Windows 7, you just need to be aware of a few issues:

• do not try to write files to protected Windows folders such as any folder derived from Program Files or Windows, or the root folder.
• Registry preferences should be stored in HKCU
• If you need Admin rights for your application, you should request this in the manifest XML file – see here
• You should consider using a TThemeManager to enable XP themes support and give your app a XP feel.
• Themes and Vista menus are likewise activated through the manifest XML file, but you should probably add some additional Vista/Win7 specific code to handle this.

RedCoal supplies an API for its MIDA technology with VB and C++ examples but no Delphi code.

I have created a Delphi demo with code using Delphi 2007, which you can download and use free of charge.

Of course, to actually use the SMS text service, you will need to download the SDK from RedCoal which includes a serial number generator which provides the serial number for your application, and you will need to email them for a trial SMS Key (developer’s trial lasts 1 month then there is a one off royalty free developer’s license of $A695).

Finally, your client will need to open an SMS text service account with RedCoal to pay for the actual SMS texts sent (17-22c per SMS for pre-paid).

Post script:

If you deploy this in an organisation which uses a proxy server for internet, then you will need to detect this and set the HTTPWebNode.proxy property which must be in the format server:port (fortunately, this is the format used in Windows registry as outlined below):

for example:

RedCoalRIO.HTTPWebNode.Proxy := GetInternetProxy;

function GetInternetProxy:String;
var reg:TRegistry;
begin
result := ”;
Reg := TRegistry.Create;
try
Reg.RootKey := HKEY_CURRENT_USER;
if Reg.OpenKey(‘\Software\Microsoft\Windows\CurrentVersion\Internet Settings’,False) then
if Reg.readBool(‘ProxyEnable’) then
begin
Reg.CloseKey;
if Reg.OpenKey(‘\Software\Microsoft\Windows\CurrentVersion\Internet Settings’,False) then
Result := Reg.readString(‘ProxyServer’);
end;
finally
Reg.CloseKey;
Reg.Free;
end;
end;