Delphi Tips,Delphi News,Delphi Notes

Delphi Prism ASP.NET web chat service

2010-03-05T21:04:00.000-08:00

Using Delphi 2010, we can build ASP.NET web services and projects, as I often demonstrate in my ASP.NET workshops and training events (in The Netherlands, UK and Sweden for example). In this article, I'll demonstrate how we can use Delphi Prism and ASP.NET to write a web chat service, consuming it in an ASP.NET web form as well.
In order to participate with the demo of this month, you need a copy of Delphi Prism. After starting Delphi Prism, do File | New ?Project, and in the Web node of the Delphi Prism project types, select the ASP.NET Web Application. Specify WebChat as name of the application. This will create a new solution with one project called WebChat

Unfortunately, inside the generated source code in file chat.asmx.pas the [WebMethod] attribute still appears above the implementation of the example method chat.HelloWorld instead of the definition of this method in the chat class. We need to move that attribute from the implementation to the definition. In fact, we don't need the entire HelloWorld method at all, so feel free to remove both the definition and implementation.
For the chatroom example, I need two methods: one to send a chat message, and another to retrieve all chat messages.

Delphi 2010 Delayed Dynamic Link Libraries

2010-03-05T21:01:00.001-08:00

Traditionally, Dynamic Link Libraries (DLLs) can be loaded in two different ways: implicit or explicit.

unit DelayedHandler;
interface
uses
SysUtils;

type
ELoadLibrary = class(Exception);
EGetProcAddress = class(Exception);

implementation

function DelayedHandlerHook(dliNotify: dliNotification;
pdli: PDelayLoadInfo): Pointer; stdcall;
begin
if dliNotify = dliFailLoadLibrary then
raise ELoadLibrary.Create('Could not load ' + pdli.szDll)
else
if dliNotify = dliFailGetProcAddress then
if pdli.dlp.fImportByName then
raise EGetProcAddress.Create('Could not load ' +
pdli.dlp.szProcName + ' from ' + pdli.szDll)
else
raise EGetProcAddress.Create('Could not load index ' +
IntToStr(pdli.dlp.dwOrdinal) + ' from ' + pdli.szDll)
end;

initialization
SetDliFailureHook(DelayedHandlerHook);
finalization
SetDliFailureHook(nil);
end.

C++Builder Developer’s Journal – Call for Papers out for May 2010 issue

2010-03-05T20:57:00.000-08:00

The C++Builder Developer’s Journal is a great magazine run by some really dedicated guys. I’ve been a subscriber for quite awhile and find it almost always has a couple of articles I’m interested in. They are very often applicable to Delphi as well. Anyway, the May 2010 issue will be an open one, meaning it will be freely available to anyone, not just subscribers. They are running a Call for Papers right now, so if you’ve had an idea for an article burning away in the back of your mind, or just like the idea of the fame and fortune that comes with being a published author (yes, I kept a straight face while typing that. Getting good at this, aren’t I?) go and check it out.

Delphi Prism 2010 Does Not Seem To Use Subdirectories

2010-03-05T20:56:00.001-08:00

When working on an ASP.NET website, I find it a lot easier if you put related sections in seperate subdirectories. For example:

CSS and Javascript can be put in a directory with caching in order to speed up the page loads

Pages that are only available to certain roles (i.e. “Admin”) can be put in a seperate directory and then you set the web.config so that only that role can access the directory. This helps to make it really clear who the page is ment for.

While attempting to port a site from Delphi RAD 2007 to Delphi Prism 2010, I was amazed that it would not let me do this. I even opened a site in Visual Web Developer 2008 (the Microsoft compeditor that Prism basically uses as the IDE) to check if it was a Microsoft issue. Not only did the Microsoft Web Developer 2008 allow it, but when I went to create a code file, it suggested putting it into app_code and offered to move it there for me (but did not force me to if I didn’t want to).

In comparison, in Delphi Prism 2010, I opened {project}\css\proj.css. Instead of allowing me to use the file where it was, Prism created a brand new file {project}\proj.css and added that to the project. To add to the confusion, it left the old file {project}\css\proj.css. Now I have two copies of proj.css. I tried it with several different files and kept having this issue.

Not only is this annoying, I find that this really makes a larger site a lot harder to maintain.

SamplingProfiler v1.7.4

2009-09-08T19:13:00.001-07:00

SamplingProfiler v1.7.4 is now available. This version adds an option for Delphi 2010 paths, and fixes a big with the silent mode execution that would render it inoperative. There also have been other minor changes, mostly cosmetic.

This release also includes preparation for an “attach to process” option, which is currently not enabled, but should hopefully make in the next version (available “when ready”).

Delphi 2010 paths added to options.
Fixed a bug in silent mode.

What To Do When You Find a Bug in Your Program

2009-09-08T19:11:00.000-07:00

No Go Answers
If possible pretend that you are the company's answering machine. "You have reached Acme LTD, we are sorry but all the support lines are busy. Please call back in 12 hours".
Answer that you are sorry but the line is lousy and you did not hear the last sentence. Blib, zzp, blip. "Could you please call us back tomorrow, or when the lines are fixed?".
Answer that you are sorry but the support team is on holidays and that they will be back in no time, in 3 months.
Answer "I do not care, leave me alone, its Friday. You asked for the application now learn to live with it".
No Go Doings
After you have reproduced the steps and actually found the bug:
Introduce new, more severe bugs. The bug from the phone call will look like child's play. When this new bug is found, introduce another one. Just keep adding more bugs.
Ignore the bug. Just continue adding extra functionality to the application. Maybe users will forget and never again run into it.
Restart your development environment. If that does not help restart Windows. If that does not help restart Windows again.
Locate the line of the source code that is responsible for the bug (note: this requires lots of your valuable time). Then do one of the following (or all):
Delete the function containing the line of code that produces the bug. If you remove the cause - the consequence (bug) will go away. If, for example, the result of the function was a Boolean value, just make sure that sometimes false is returned and sometimes true is returned for the function result.
Turn your head away from the monitor. Pretend that you are dead. Maybe it will go away.
Turn your head away from the monitor. Pretend that you are dead. Try to scare the bug by quickly looking into the source code saying "bu". Repeat until the bug is gone or the code fixes itself.
Delete the application source. Delete any marks the application ever existed. Pretend that you never created the program in the first place.
Run. Run as fast as you can.

Search your HTML documentation with HelpNDoc 2.2

2009-09-06T20:08:00.000-07:00

HelpNDoc 2.2 introduces a custom made JavaScript search engine to power the client-side searching functionality of the HTML generated documentation. This means that, without any complicated server-side technology, users will be able to search your HTML documentation with ease and speed.
PDF Generation is now more robust and the external files functionality has been totally rewritten to better handle HTML and Word documentation import. It is now easier than ever to include external files in topics.

Delphi 2010 migration was a beeze; samples/slides will be uploaded soon

2009-09-06T20:07:00.000-07:00

This week, I found some time do migrate all the sample projects to the release versions of Delphi Win32 2010 and Delphi Prism 2010.

Delphi Win32 2010 works like a charm: it is much faster and has a much smaller footprint than any other Galileo based IDE.
In fact, it feels almost as fast as the pre-Galileo based IDE’s.
With the added benefit that all the new features make me much more productive, not the least because it has not yet crashed on me this week once.
Crashing has been a frequent thing on me since Delphi 4 (maybe I should not even mention that number ), for most IDE’s at least a couple of times a week, so this is good.

Delphi Prism 2010 works really nice too, it is rock solid, and the language as some great features not found in other .NET languages.
But it still needs a tiny bit more polishing on the Visual Studio IDE Integration part.
There are a few things not as smoothly integrated as I’m used to in C# and VB .NET (for instance when adding assembly references; C# and VB.NET allow you to do that from multiple places in the IDE; Delphi Prism from only one).
I know it is nitpicking (the same holds for the Team Foundation System integration in the Visual Studio IDE: ever tried to add files or folders? There is only one icon that allows you to do it. Ever tried to move files or folders around? No way you can drag & drop, in fact you can move only 1 file or folder at a time, and then the folder tree leaves you at the target).

The Embarcadero folks have worked hard on developer productivity in the Delphi Win32 2010 IDE.
(Did I mention the F6 key? It is an awesome way of directly jumping into configuration dialogs a zillion levels deep.
Did I mention the Ctrl-D key? It instantly reformats your source code to your formatting settings).
So maybe it is now time to put some of that effort into the Prism side as well.

PDFtoolkit VCL v3.3

2009-09-06T20:04:00.001-07:00

Gnostice PDFtoolkit is a comprehensive and versatile PDF component suite for Delphi™ and C++Builder®. PDFtoolkit VCL components come with hundreds of functions and properties that put immense power in the hands of the developer. PDFtoolkit hides the complexity of the PDF format and allows developers to easily create applications that can edit, enhance, secure, merge, split, view, digitally sign, and print PDF documents and process PDF forms. PDFtoolkit can extract text, export to images, and also add digital signatures.

PDFtoolkit does not require PDF software such as Adobe PDF library, Adobe Acrobat Professional, Adobe PDF Reader or GhostScript.

Note: PDFtoolkit works on existing documents. For creating new PDF documents in Delphi or C++Builder, you can use eDocEngine VCL. For other platforms, we have PDFOne .NET and PDFOne Java, which can create PDF documents from scratch as well as modify existing PDF documents.

Memory Manager Tool FastMM 4.94

2009-09-06T20:01:00.000-07:00

FastMM is a lightning fast replacement memory manager for Borland Delphi Win32 applications that scales well in multi-threaded applications, is not prone to memory fragmentation, and supports shared memory without the use of external .DLL files.

download

TurboPower Orpheus 4.06 for Delphi 2010

2009-09-06T19:59:00.000-07:00

Orpheus is an award-winning UI toolkit for Borland Delphi &C++Builder. It contains over 120 components covering everything fromdata entry to calendars and clocks. Other noteworthy componentsinclude an Object Inspector, LookOut bar, & report views.

download

IDE Fix Pack 2010 – ObjectInspector F1 key

2009-09-06T19:58:00.000-07:00

I got many requests to add a patch for the non-functioning F1 key in the Object Inspector. So I spend 2 hours trying to find out where the F1 got lost and what Delphi 2009 does what 2010 doesn’t. My research showed that Delphi 2009 calls a function named “ShowPropertyHelp” while Delphi 2010 skips this call. Before the call to ShowPropertyHelp there is a call to a function named “GetTrait”.In Delphi 2009 it returns an interface while in Delphi 2010 it returns nil.

Then I remembered that I saw something in ToolsAPI.pas that was called “Traits”. So I looked into it and found the IOTAPersonalityServices interface. By analyzing the GetTrait “call parameters” I was able to extract the GUID that is used for the IOTAPersonalityServices.GetTrait(ATraitGUID) parameter. It seems that in Delphi 2010 the Property-Help trait is missing or GetTrait doesn’t return it.

The next step was to try to add the “trait” by calling the IOTAPersonalityServices.AddPersonalityTrait method with the personality ID and the extracted GUID. And vólà the F1 key in the Object Inspector is back.

Class (, Static, or Shared) Constructors (and Destructors)

2009-09-03T18:43:00.001-07:00

Improved encapsulation
How many times have you needed to initialize something related to a specific class? What if your class is using the singleton pattern and you need to create that single instance? How about registering the class with a “class-factory?” Prior to Delphi 2010, there were several options available to you, none of which were really in keeping with the OOP notion of encapsulation. You could put all the code into the initialization section of the unit in which the class lived, add a regular class method and call it explicitly, or manually integrate the init code into your application’s startup. By moving all this code into a class constructor, the mere act of “touching” the class will cause the class constructor to run in keeping with the above rules.

Better control over smart-linking
Loosely coupled with improved encapsulation is the notion that by moving any initialization code into the class constructor you have a little more control over what code is linked into your application. You can now take advantage of the fact that as long as the class type isn’t referenced referenced anywhere in your code, none of the code related to the class type is linked in, including the VMT, virtual methods, RTTI, etc.. If you had placed this init code into the initialization section of its containing unit, then at least the VMT, virtual methods and RTTI would have been linked into your application. Even though none of your code references it. The new enhanced RTTI throws an interesting wrinkle to this theory, but that will have to be covered later.

Better language compatibility with Delphi Prism
As Delphi Prism gains popularity, more people will need to maintain some of their code in a manner that they can compile with either compiler. There are still many language constructors that both compilers have that the other doesn’t, but this is a continuing effort to close that gap where it makes sense. Expect to see more work in this area, in both compilers.

In my next post, we’ll “pop the hood” (or bonnet, for our good friends across the pond) and take a peek at how they work and exactly when they are invoked. I will say that many people tend to read way, way too much into this simple statement describing when a class constructor is invoked; “Called automatically to initialize the class before the first instance is created or any static members are referenced.” The only temporal reference in that statement is “…before…”. I will leave you to consider the implications of that word, lest many of you begin to talk about “threading issues” and “code-bloat.” Class constructors and destructors are to classes as initialization and finalization are to units.

SmartInspect now supports Delphi 2010

2009-09-03T18:39:00.000-07:00

We have just released a new version of our .NET, Java and Delphi logging tool SmartInspect that supports the new Delphi 2010. Embarcadero’s latest Delphi version looks like a very solid release and we have seen other people report that there are good chances that Delphi 2010 will become the new reference version for many years to come.

As usual, existing SmartInspect customers can download the new release from our customer portal. If you are interested in giving SmartInspect a try, please download the updated trial version with Delphi 2010 support from our website.

Delphi 2010’s RTTI and Active Scripting

2009-09-02T18:25:00.000-07:00

I’ve been playing around with the new RTTI stuff in the D2010 trial, and I have to say, I’m impressed. But for what it surfaces for method pointers (= event types) and sets, it seems both very complete and very intuitive to use. Not only have I managed to use it without having reference to either source code or an API reference (though let’s not encourage Embarcadero on the latter, eh?), but it has been generally very solid — do something wrong, and an appropriate exception is cleanly raised with a message that tells you straighaway what the issue is. The one (er) exception to this is TValue not doing quite enough verification when attempting a cast to a Variant, though as the latter is an explicit operation, it’s easy enough to work around if and when it bites.

That said, reading the small amount of documentation, I happened across mention of an Invoke method, which set me thinking — is it finally possible to cleanly (and generically!) wrap Delphi objects into IDispatch ones for use in Active Scripting? Well, apart from the events issue and the difficulties of surfacing set types in a script-friendly manner, my answer is: for sure! Check out this compiled EXE if you’re interested (screenshot here).

Basically, what I’ve done is to write a TCustomDispProxy class with TObjectDispProxy and TClassDispProxy descendants; in the demo, these are then used to directly surface the Application, Mouse and Screen objects, together with the form instance (object properties and fields are handled automatically) and some metaclasses (TButton, TLabel, etc.).The idea is that no specific object or class type requires a specific wrapper — all just use TObjectDispProxy and TClassDispProxy respectively, with wrappers for sub-objects created on the fly. Now unlike Allen Bauer, I’m not a masochist in these things, and so have used the MS Script Control rather than implemented the Active Scripting interfaces directly; because of this, be warned that if the control isn’t installed (which is unlikely these days, though could be the case), the EXE won’t run.

Anyhow, if anyone’s interested in the actual code, add a comment saying so and I’ll endeavour to do it up for public consumption. Alternatively, if you’re not interested, then don’t leave a comment and I won’t bother

Custom Marshalling/UnMarshalling in Delphi 2010

2009-09-02T18:17:00.000-07:00

Introduction
Some days ago, Embarcadero has presented the new version of RAD Studio, 2010.
The are many new features, but you can find in a lot places around the web, so
I won’t repeat them here.

One of the things widely requested from all Delphi programmers all over the world over the past few years, including myself, is
certainly a new and more powerful RTTI.

The new system of RTTI has finally arrived, and pave the way for a large number of applications.
One area that has benefited from the new RTTI is for sure the marshaled objects.

Marshaling is defined as follows:

“In computer science, marshalling (similar to serialization) is the process of
transforming the memory representation of an object to a data format suitable for
storage or transmission. It is typically used when data must be moved between
different parts of a computer program or from one program to another.
The opposite, or reverse, of marshalling is called unmarshalling (demarshalling) (similar to deserialization).”
–WikiPedia

In Delphi 2010 the process of serialization and deserialization is handled respectively by a Marshaller and an Unmarshaller.

The built-in format for the serialization of any Delphi object is JSON.
There are 2 main classes responsible for serializing objects into JSON, both present in the unit DBXJSONReflect:
- TJSONMarshal
- TJSONUnMarshal

Let’s say you have an object defined as follow:

Code

type
  TKid = class
    FirstName: String;
    LastName: String;
    Age: Integer;
  end;

To serialize and deserialize an instance of TKid it requires the following steps:

Code

var
  Mar: TJSONMarshal;  //Serializer
  UnMar: TJSONUnMarshal;  //UnSerializer
  Kid: TKid;  //The Object to serialize
  SerializedKid: TJSONObject;  //Serialized for of object
begin
  Mar := TJSONMarshal.Create(TJSONConverter.Create);
  try
    Kid := TKid.Create;
    try
      Kid.FirstName := 'Daniele';
      Kid.LastName := 'Teti';
      Kid.Age := 29;
      SerializedKid := Mar.Marshal(Kid) as TJSONObject;
    finally
      FreeAndNil(Kid);
    end;
  finally
    Mar.Free;
  end;
  //Output the JSON version of the Kid object
  WriteLn(SerializedKid.ToString);
  // UnMarshalling Kid
  UnMar := TJSONUnMarshal.Create;
  try
    Kid := UnMar.UnMarshal(SerializedKid) as TKid;
    try
      //now kid is the same as before marshalling
      Assert(Kid.FirstName = 'Daniele');
      Assert(Kid.LastName = 'Teti');
      Assert(Kid.Age = 29);
    finally
      Kid.Free;
    end;
  finally
    UnMar.Free;
  end;
end;

Simple, isn’t it?
To access the JSON string that is our object, we must call the method ToString.
The JSON representation of this object SerializedKid can be saved to file,
sent to a remote server, used by a Web page from a web service, stored on a database or sent into space (!!!).
The Delphi application re-read the JSON string, you can recreate the object as it was at the time of serialization.
But anyone with a JSON parser can still read the data in our object, even non Delphi client.
These are the advantages of having used an open format and standard.

So far the simple part …
How serialize a field differently from the default?

Suppose we add the date of birth to our TKid:

Code

type
  TKid = class
    FirstName: String;
    LastName: String;
    Age: Integer;
    BornDate: TDateTime;
  end;

Serialize a TDateTime, localized and that I have in JSON string is a float, because for Delphi TDateTime is a decimal number.
If I read the data from another program Delphi, no problem, but if I wanted to read a script in JavaScript? or. NET? or Ruby?
Then I use a format “DATA” to understand, even for these languages.
The new engine provides the serialization too.
Is needed, however, to tell the Marshaller and UnMarsheller how to represent and reconstruct a particular
object field by two statements like the following:

Code

//marshaller
Marshaller.RegisterConverter(TKid, 'BornDate',
  function(Data: TObject; Field: string): string
  var
    ctx: TRttiContext; date : TDateTime;
  begin
    date := ctx.GetType(Data.ClassType).GetField(Field).GetValue(Data).AsType;
    Result := FormatDateTime('yyyy-mm-dd hh:nn:ss', date);
  end);
//UnMarshaller
UnMarshaller.RegisterReverter(TKid, 'BornDate',
  procedure(Data: TObject; Field: string; Arg: string)
  var
    ctx: TRttiContext;
    datetime:TDateTime;
  begin
    datetime := EncodeDateTime(StrToInt(Copy(Arg, 1, 4)),
                               StrToInt(Copy(Arg, 6, 2)),
                               StrToInt(Copy(Arg, 9, 2)),
                               StrToInt(Copy(Arg, 12, 2)),
                               StrToInt(Copy(Arg, 15, 2)),
                               StrToInt(Copy(Arg, 18, 2)), 0);
    ctx.GetType(Data.ClassType).GetField(Field).SetValue(Data, datetime);
  end);

The anonymous method is called when the marshaller serializes the field ‘BornDate’ is called “Converter” while Unmarshaller anonymous method that calls when he has to reconstruct the object from the JSON string is the “Reverter”.
Thus serializing a TKid assure you that my object is readable both by Delphi from another language without loss of information.

But what happens when I have to serialize a complex type?

Suppose we extend TKid this:

Code

type
  TTeenager = class(TKid)
    Phones: TStringList;
    constructor Create; virtual;
    destructor Destroy; virtual;
  end;

We must define a Converter and a Reverter for the TStringList class.
We can do it this way:

Code

var
  Marshaller: TJSONMarshal;
  UnMarshaller: TJSONUnMarshal;
  Teenager: TTeenager;
  Value, JSONTeenager: TJSONObject;
begin
  Marshaller := TJSONMarshal.Create(TJSONConverter.Create);
  try
    Marshaller.RegisterConverter(TTeenager, 'BornDate',
      function(Data: TObject; Field: string): string
      var
        ctx: TRttiContext; date : TDateTime;
      begin
        date := ctx.GetType(Data.ClassType).GetField(Field).GetValue(Data).AsType;
        Result := FormatDateTime('yyyy-mm-dd hh:nn:ss', date);
      end);
    Marshaller.RegisterConverter(TStringList, function(Data: TObject): TListOfStrings
                                              var
                                                i, count: integer;
                                              begin
                                                count := TStringList(Data).count;
                                                SetLength(Result, count);
                                                for i := 0 to count - 1 do
                                                  Result[i] := TStringList(Data)[i];
                                              end);  //TStringList Converter
    Teenager := TTeenager.CreateAndInitialize;
    try
      Value := Marshaller.Marshal(Teenager) as TJSONObject;
    finally
      Teenager.Free;
    end;
  finally
    Marshaller.Free;
  end;
  // UnMarshalling Teenager
  UnMarshaller := TJSONUnMarshal.Create;
  try
    UnMarshaller.RegisterReverter(TTeenager, 'BornDate',
      procedure(Data: TObject; Field: string; Arg: string)
      var
        ctx: TRttiContext;
        datetime: TDateTime;
      begin
        datetime := EncodeDateTime(StrToInt(Copy(Arg, 1, 4)),
                                   StrToInt(Copy(Arg, 6, 2)),
                                   StrToInt(Copy(Arg, 9, 2)),
                                   StrToInt(Copy(Arg, 12, 2)),
                                   StrToInt(Copy(Arg, 15, 2)),
                                   StrToInt(Copy(Arg, 18, 2)), 0);
        ctx.GetType(Data.ClassType).GetField(Field).SetValue(Data, datetime);
      end);
    UnMarshaller.RegisterReverter(TStringList, function(Data: TListOfStrings): TObject
                                               var
                                                 StrList: TStringList;
                                                 Str: string;
                                               begin
                                                 StrList := TStringList.Create;
                                                 for Str in Data do
                                                   StrList.Add(Str);
                                                 Result := StrList;
                                               end);  //TStringList Reverter
    Teenager := UnMarshaller.Unmarshal(Value) as TTeenager;
    try
      Assert('Daniele' = Teenager.FirstName);
      Assert('Teti' = Teenager.LastName);
      Assert(29 = Teenager.Age);
      Assert(EncodeDate(1979, 11, 4) = Teenager.BornDate);
      Assert(3 = Teenager.Phones.Count);
      Assert('NUMBER01&#8242;=Teenager.Phones[0]);
      Assert('NUMBER02&#8242;=Teenager.Phones[1]);
      Assert('NUMBER03&#8242;=Teenager.Phones[2]);
    finally
      Teenager.Free;
    end;
  finally
    UnMarshaller.Free;
  end;
end;

There are different types of Converter and Reverter.
In the the DBXJSONReflect there are 8 types of converters:

Code

 
  //Convert a field in an object array
  TObjectsConverter = reference to function(Data: TObject; Field: String): TListOfObjects;
  //Convert a field in a strings array
  TStringsConverter = reference to function(Data: TObject; Field: string): TListOfStrings;
  //Convert a type in an objects array
  TTypeObjectsConverter = reference to function(Data: TObject): TListOfObjects;
  //Convert a type in a strings array
  TTypeStringsConverter = reference to function(Data: TObject): TListOfStrings;
  //Convert a field in an object
  TObjectConverter = reference to function(Data: TObject; Field: String): TObject;
  //Convert a field in a string
  TStringConverter = reference to function(Data: TObject; Field: string): string;
  //Convert specified type in an object
  TTypeObjectConverter = reference to function(Data: TObject): TObject;
  //Convert specified type in a string
  TTypeStringConverter = reference to function(Data: TObject): string;

Each of them deals with a particular conversion object representation in the final serialization, in our case we will use them to convert to JSON.

Also in the DBXJSONReflect unit are defined many “Reverter” dealing with retrieving
the serialized version of the data and use it to reconstruct the object previously serialized.
Because they are complementary to the Converter, I will not copy them here.

As a final example, we derive from TProgrammer by TTeenager adding a list of Laptops in the properties.

Is therefore necessary to introduce a new pair of Converter / Reverter.
In this example I have defined all the converter and reverter in another unit in
order to have more readable code:

Code

type
  TLaptop = class
    Model: String;
    Price: Currency;
    constructor Create(AModel: String; APrice: Currency);
  end;
  TLaptops = TObjectList;
  TProgrammer = class(TTeenager)
    Laptops: TLaptops;
    constructor Create; override;
    destructor Destroy; override;
    class function CreateAndInitialize: TProgrammer;
  end;
// Implementation code&#8230;
var
  Marshaller: TJSONMarshal;
  UnMarshaller: TJSONUnMarshal;
  Programmer: TProgrammer;
  Value, JSONProgrammer: TJSONObject;
begin
  Marshaller := TJSONMarshal.Create(TJSONConverter.Create);
  try
    Marshaller.RegisterConverter(TProgrammer, 'BornDate', ISODateTimeConverter);
    Marshaller.RegisterConverter(TStringList, StringListConverter);
    Marshaller.RegisterConverter(TProgrammer, 'Laptops', LaptopListConverter);
    Programmer := TProgrammer.CreateAndInitialize;
    try
      Value := Marshaller.Marshal(Programmer) as TJSONObject;
    finally
      Programmer.Free;
    end;
    // UnMarshalling Programmer
    UnMarshaller := TJSONUnMarshal.Create;
    try
      UnMarshaller.RegisterReverter(TProgrammer, 'BornDate', ISODateTimeReverter);
      UnMarshaller.RegisterReverter(TStringList, StringListReverter);
      UnMarshaller.RegisterReverter(TProgrammer, 'Laptops', LaptopListReverter);
      Programmer := UnMarshaller.Unmarshal(Value) as TProgrammer;
      try
        Assert('Daniele' = Programmer.FirstName);
        Assert('Teti' = Programmer.LastName);
        Assert(29 = Programmer.Age);
        Assert(EncodeDate(1979, 11, 4) = Programmer.BornDate);
        Assert(3 = Programmer.Phones.Count);
        Assert('NUMBER01&#8242; = Programmer.Phones[0]);
        Assert('NUMBER02&#8242; = Programmer.Phones[1]);
        Assert('NUMBER03&#8242; = Programmer.Phones[2]);
        Assert('HP Presario C700&#8242; = Programmer.Laptops[0].Model);
        Assert(1000 = Programmer.Laptops[0].Price);
        Assert('Toshiba Satellite Pro' = Programmer.Laptops[1].Model);
        Assert(800 = Programmer.Laptops[1].Price);
        Assert('IBM Travelmate 500&#8242; = Programmer.Laptops[2].Model);
        Assert(1300 = Programmer.Laptops[2].Price);
      finally
        Programmer.Free;
      end;
    finally
      UnMarshaller.Free;
    end;
  finally
    Marshaller.Free;
  end;
end;

Unit CustomConverter.pas contains all needed Converters/Reverts as anon methods.

Code

unit CustomConverter;
interface
uses
  DBXJSONReflect,
  MyObjects; //Needed by converter and reverter for TLaptops
var
  ISODateTimeConverter: TStringConverter;
  ISODateTimeReverter: TStringReverter;
  StringListConverter: TTypeStringsConverter;
  StringListReverter: TTypeStringsReverter;
  LaptopListConverter: TObjectsConverter;
  LaptopListReverter: TObjectsReverter;
implementation
uses
  SysUtils, RTTI, DateUtils, Classes;
initialization
LaptopListConverter := function(Data: TObject; Field: String): TListOfObjects
var
  Laptops: TLaptops;
  i: integer;
begin
  Laptops := TProgrammer(Data).Laptops;
  SetLength(Result, Laptops.Count);
  if Laptops.Count > 0 then
    for I := 0 to Laptops.Count - 1 do
      Result[I] := Laptops[i];
end;
LaptopListReverter := procedure(Data: TObject; Field: String; Args: TListOfObjects)
var
  obj: TObject;
  Laptops: TLaptops;
  Laptop: TLaptop;
  i: integer;
begin
  Laptops := TProgrammer(Data).Laptops;
  Laptops.Clear;
  for obj in Args do
  begin
    laptop := obj as TLaptop;
    Laptops.Add(TLaptop.Create(laptop.Model, laptop.Price));
  end;
end;
StringListConverter := function(Data: TObject): TListOfStrings
var
  i, count: integer;
begin
  count := TStringList(Data).count;
  SetLength(Result, count);
  for i := 0 to count - 1 do
    Result[i] := TStringList(Data)[i];
end;
StringListReverter := function(Data: TListOfStrings): TObject
var
  StrList: TStringList;
  Str: string;
begin
  StrList := TStringList.Create;
  for Str in Data do
    StrList.Add(Str);
  Result := StrList;
end;
ISODateTimeConverter := function(Data: TObject; Field: string): string
var
  ctx: TRttiContext; date : TDateTime;
begin
  date := ctx.GetType(Data.ClassType).GetField(Field).GetValue(Data).AsType;
  Result := FormatDateTime('yyyy-mm-dd hh:nn:ss', date);
end;
ISODateTimeReverter := procedure(Data: TObject; Field: string; Arg: string)
var
  ctx: TRttiContext;
  datetime :
  TDateTime;
begin
  datetime := EncodeDateTime(StrToInt(Copy(Arg, 1, 4)), StrToInt(Copy(Arg, 6, 2)), StrToInt(Copy(Arg, 9, 2)), StrToInt
      (Copy(Arg, 12, 2)), StrToInt(Copy(Arg, 15, 2)), StrToInt(Copy(Arg, 18, 2)), 0);
  ctx.GetType(Data.ClassType).GetField(Field).SetValue(Data, datetime);
end;
end.

Last hint…
Every serialization/unserialization process can create “warnings”.
Those warnings are collected into the “Warnings” property of the Ser/UnSer Object.

Conclusions
In this post I tried to introduce the basics of the new serialization engine in Delphi 2010.
During the next ITDevCon to be held in Italy next November 11.12, I’ll have a talk in which I will extensively talk about serialization and RTTI.
All interested smart developers are invited

ITALIAN P.S.
Se qualche programmatore italiano volesse avere la versione in italiano di questo post può lasciare un commento e vedrò di accontentarlo

You can find the DUnit project Source Code

What’s new in the Delphi and C++Builder Debugger

2009-09-02T18:14:00.000-07:00

Want to find out? Be sure to sign up for CodeRage and check out my session. I just put the final touches on my presentation today. It’s nearly 35 minutes of non-stop demos showing many of the new debugger features in Delphi 2010 and C++Builder 2010. Several of the features have been blogged about already (by myself and others), but there are many things shown in the session that I haven’t seen mentioned yet, plus it’s always useful to see some features in action rather than just reading about them.

My session will debut on Tuesday and then be repeated on Friday.

Looks like there are plenty of great sessions throughout the week.

Dynamically compiling code with Delphi Prism

2009-09-02T18:12:00.001-07:00

Delphi Prism and the .NET Framework are both extremely powerful tools and bring a lot of flexibility that Delphi for Win32 cannot necessarily provide, particularly when it comes to reflection and code generation. I recently started a project where I wanted to be able to compile a string with Delphi Prism code into an assembly without hacking my way around with the Delphi Prism command line compiler. This could be used to potentially create a Delphi Prism Snippet Compiler similar to the .NET Snippet Compiler from Jeff Key.

It is my intention that this post should introduce you to the process of dynamically compiling code and that the next part will hopefully be an introduction to the process of dynamically generating and compiling code using the .NET CodeDom.

To begin with, create a New Console Application in Delphi Prism and Add a Reference to the RemObjects.Oxygene.CodeModel assembly. For my installation, this was found in the Bin directory of the Delphi Prism program files directory.

Lazarus article on Linux Journal

2009-08-10T16:22:00.000-07:00

I finally got around to browse the Linux Journal Magazine (September 2009) that this month features cross platform development, and noticed the word Lazarus at the top of the cover page. Yes, it is an article about the Delphi like IDE. The article is written by Mattias Gaertner, a member of the Lazarus project.

The article is an overview of Lazarus/FPC and cross platform development. It explores Lazarus/FPC cross platform capabilities and dices into some of the IDE features. The cool aspect of this article is that is being presented in a non Delphi venue that is dedicating it’s pages to cross platform development. This exposing a Pascal IDE to a “new” audience.

Most certainly, Lazarus brings to the table cross platform development in a way that is more native to your target than .NET et al. Lazarus produces native code for Windows, Macs and Linux. I can only imagine where we could have been if Borland would have gotten Kilyx right… In any case, I have played with Lazarus and FPC for the past couple of years and I am to a point that I am willing to start a small cross platform project solely using Lazarus and FPC.

Here is a link to the article – unfortunately one has to be a subscriber to read. If you are not a subscriber, you can go to your local newsstand or book store and read the article.

RAD Studio 2010: First Preview

2009-08-10T16:19:00.000-07:00

It seems that Embarcadero sat in stone the release date of RAD Studio 2010. And it’s closer than others might expect: 24/25 August (depends on what part of the Globe you’re on). Also, it seems that IDE and the Debugger (as is shown in the video bellow)… were significantly improved in this release. I do think that after a long time these areas receive improvements, thing which is pretty encouraging. But we’ll see how each feature will pass the ‘community test’.

See for yourself at:

http://www.embarcadero.com/rad-studio-2010/

RAD Studio 2010: ToolsAPI enhancements

2009-08-10T16:16:00.000-07:00

With all the news filtering out about new IDE features and enhancements in RAD Studio 2010, I wanted to provide a quick "highlight" list of new things in the ToolsAPI, several of which correspond directly to new features. It should give you an idea of new things you can accomplish via IDE addins. Each bullet item also indicates the new or enhanced interfaces associated with the new feature.

Support for creating dockable views in the IDE. This was previously achievable using the technique described by Allen in this article: http://edn.embarcadero.com/article/21114. Now, however, there is an official ToolsAPI way to do this. The TStrings Debugger Visualizer source can serve as one example of using the new interface. Pertinent interfaces: INTACustomDockableForm and INTAServices

Support for plugging in addtional views in the editor space. There is support for creating new top-level editor tabs (similar to the debugger’s CPU View or Modules view and the new C++ Class Explorer) as well as creating additional bottom-level tabs (similar to the "Code", "Design" and "History" tabs). I have a very simple example that creates both types of tabs. I’ll try to get it cleaned up and posted to CodeCentral soon. Pertinent interfaces: INTACustomEditorView, INTACustomEditorViewState, INTACustomEditorViewStatusPanel, INTACustomEditorSubView, and IOTAEditorViewServices and INTAEditorServices.

Support for IDE Insight. Stay tuned to Mark’s blogs for more information here. Pertinent interfaces: INTAIDEInsightItem, IOTAIDEInsightCategory, IOTAIDEInsightNotifier, and IOTAIDEInsghtServices.

There is enhanced support for adding menu items into the Project Manager local menu. The support provides more flexibility in terms of when and where your menu items appear. Pertinent interfaces: IOTAProjectMenuItemCreatorNotifier, IOTAProjectManager, IOTAProjectMenuContext, and IOTAProjectManagerMenu.

IOTAProject has been enhanced to provide more complete information about which files make up a project, as well as providing better information regarding file renames and deletions. Pertinent interface: IOTAProject.

Support for wrtiting and registering debugger visualizers. There are sample visualizers that ship with RAD Studio 2010 that demonstrate how to use these interfaces. You can find the source in the Source\Win32\Visualizers directory under the Rad Studio 2010 installation directory. Pertinent interfaces: IOTADebuggerVisualizer, IOTADebuggerVisualizerValueReplacer, IOTADebuggerVisualizerExternalViewer, IOTADebuggerVisualizerExternalViewerUpdater, and IOTADebuggerServices.

Several debugger interfaces have been enhanced to support new features in the debugger (thread-specific breakpoints, freezing/thawing threads), as well as providing access to other information from the debugger (thread names, asking whether a particular type descends from another type, better access to module breakpoints). Pertinent interfaces: IOTAThread, IOTABreakpoint, and IOTADebuggerServices.

Support for build system notifications (CompileStarted/CompileFinished events for Projects and ProjectGroups) as well as other build system services. Pertinent interfaces: IOTACompileNotifier and IOTACompileServices.

New support for adding version control systems to the IDE. Pertinent interfaces: IOTAVersionControlNotifier and IOTAVersionControlServices.

The IOTAElideActions interface (code folding support) has been enhanced to allow more code folding actions to be accessed via the ToolsAPI. Pertinent interface: IOTAElideActions.

As always, the source code comments in the ToolsAPI.pas unit is the place to look for information for most of these ToolsAPI additions.

And just because I’m sure someone will ask, there is still no "official" documentation of the ToolsAPI, though I’ve had several inquiries from the documentation team about reviving the old (circa Delphi 7) ToolsAPI documentation. So it wouldn’t surprise me to see the official documentation return in one form or another sometime in the future.

TxdsControlsStates V1.1

2009-07-25T16:48:00.000-07:00

TxdsControlsStates is Delphi Component to store states of controls and components on your form to recall later during run-time.

TxdsControlsStates allows you to eliminate that series of assignments and replace it with single method call to

TxdsControlsStates.RestoreState(StateName:String);

The set of Component Properties and States are defined during design-time in property editor.

Download here

ATFileNotification V1.1.4

2009-07-25T16:46:00.000-07:00

ATFileNotification is a non-visual component, which allows to watch for files/directories changes and to fire an event when change occurs.
It is improved version of fisFileNotification component. Improvements are:

Component made Unicode compatible
FileName property added: you can watch for changes in a single file
Attempt to make component thread-safe (need feedback about it)

AutoCorrect Components v1.0

2009-07-25T16:42:00.000-07:00

What does the code do exactly?

Implements for TCustomEdit and TCustomCombo descendents a large sub-set of the AutoCorrect functionality had by ‘proper’ word processors. Specifically, the following is implemented:

User-defined ‘replace text as you type’ entries, including formatted ones if the active control is a rich edit.
TWo INitial CApitals correction, with an exception list that is automatically added to when the user immediately undoes a correction.
Conversion of ’straight’ quotes into ‘curly’ (‘smart’) quotes.
Conversion of hyphens to dashes: two hyphens in a row (–) turn into an em-dash, a hyphen with a space either side ( – ) becomes an en-dash with a space either side.
Conversion of 1/2 to ½, 1/4 to ¼, and 3/4 to ¾.
Auto-indentation for rich edit controls — in other words, allows the user to set the active paragraph’s left- and first-indent properties by tabbing and backspacing.
How does it work?

In essence, the code works by trapping the KeyPress method (OnKeyPress event) of the active control, testing for a trigger key that will lead to correction testing proper kicking in. The initial trapping, however, is ‘manual’ in the sense that the TAutoCorrectEngine component does not actively ‘seek out’ key press events — it needs to be told about them.

What’s the quickest way to see it in action?

Download the code from here (EDN registration required — it’s free and relatively easy to do though), open up the ‘AutoCorrect demo and design-time package’ project group, and run the last project listed (AutoCorrectDemo.dpr). Since the TAutoCorrectEngine component is created at runtime for the demo, no installation is required.

How do I use the code myself?

Firstly, compile and install the design-time package, dclCCRAutoCorrect.dpk. This should lead to five new components being added to the component palette: TAutoCorrectEngine, TComboBoxWithAutoCorrect, TEditWithAutoCorrect, TMemoWithAutoCorrect and TRichEditWithAutoCorrect.
Ensure CCR.AutoCorrect.dcu and CCR.AutoCorrect.Consts.dcu end up somewhere in your library paths — the easiest way to do this is to add the component’s directory as a library path itself. In Delphi 2007, you do this by going to ToolsOptions, Environment Options -> Delphi Options -> Library – Win32, and clicking on the ellipsis button for ‘Library path’.
Create a new VCL forms application and add a TAutoCorrectEngine component to the main form; double click the component to add some custom ‘replace-as-you-type’ entries.
Add one or more TxxxWithAutoCorrect controls to the form, and assign their AutoCorrectEngine property to the TAutoCorrectEngine component.
Compile and run.
But I don’t want to use your custom descendants of TEdit, TRichEdit, etc.!

No problem — you’ll just have to do a bit of manual work, calling as appropriate the KeyDownOccurred, KeyPressOccurred and UndoOccurred methods of the TAutoCorrectEngine component. The last of these is best done by defining an undo action (i.e., a TAction with Ctrl+Z as its shortcut), UndoOccurred being called immediately after the undo operation is performed. As for the other two, you can either handle the OnKeyXXX events of the controls themselves or (if you set KeyPreview to True) the parent form — in the second case, pass ActiveControl as the first parameter to KeyXXXOccurred. See the main demo for an example of all this — the process is simpler than it may sound.

The small print

Target Delphi versions: separate versions for Delphi 7 on the one hand, and Delphi 2006 or greater on the other, are included in the ZIP — both versions’ functionality and implementation are almost identical however.

Turbo Delphi Explorer compatibility: since you don’t need to install TAutoCorrectEngine to actually use it, and adding custom entries at runtime is pretty easy. Check out the main demo, which doesn’t use a design-time instance of the component and so can be open and run from inside the Turbo Delphi IDE.

Rich edit bugs: note that the TRichEditWithAutoCorrect class works around bugs in the underlying DLL the VCL’s TCustomRichEdit wraps. Specifically, v1 of the DLL (used until Delphi 2009) uncurls smart quotes when they are streamed or pasted in, and v1 to v3 of the DLL don’t load en- and em-dashes correctly, loading them as hyphens.

We have huge amounts of memory and concurrent programming is an exception

2009-05-23T05:29:00.000-07:00

It's quite amazing to hear Anders advocating bloat in a world where most of the world still has bad internet connections and hate large downloads, mobile phones prefer 1MB applications over 10MB apps, where RAM can be a bottleneck, where battery life is always too short and where many large organizations struggle with bad performance.

I recently had the chance to see the standard configuration for virtual servers in a large organization. In order to improve network traffic, the standard network adapter is limited to 10Mbit/sec.

Add-in Express 2009 for Office and VCL

2009-05-23T05:20:00.000-07:00

Visual designers and components of Add-in Express in combination with a perfect Delphi compiler provide you with the best platform for Office development. Add-in Express makes it equally easy to build toolbars, menus and sub-menus for Microsoft Office 2000 – 2003, customize the Office 2007 Ribbon using the Office 2007 Ribbon designer as well as to create custom static and contextual ribbon tabs, task panes, navigation pane and reading pane, Office Menu and Quick Access Toolbar.

Add-in Express for Delphi implements all interfaces and techniques required by supported technologies, you write functional code only. Another key benefit of Add-in Express is version neutrality – you write the plug-in code once and get a secure Microsoft Office extension that works for all applications and versions.

Plug-in types: COM add-ins, smart tags, real-time data servers
Office versions: Office 2000, 2002, 2003, 2007
Applications: Outlook, Word, Excel, PowerPoint, Access, Publisher, Project, MapPoint, InfoPath, Visio
IDEs: Delphi 5, 6, 7, 2006, 2007, 2009
Windows Vista ready

DataSnap the fastest multi-tier development

2009-05-20T05:58:00.000-07:00

The new approach was introduced with RAD Studio 2009 (including Delphi & C++Builder) and was based on a NON-COM/DCOM approach. The new approach used JSON (JavaScript Object Notation) http://www.json.org/ housed on a TCP/IP message layer wrapped in the DataSnap technology.

What makes this approach great is that it is simple to implement:

Create a DataSnap Server
1. Create a VCL Form application
2. Add the 3 DataSnap Server components
3. Connect the Server components
4. Add a ServerModule (this is where the developer exposes business logic and data from the backend storage)
5. Connect the ServerModule to the Server components for the wire protocol and transfer of information

Create a client (generic client)
1. Create a VCL form application, Web application, ASP.NET (Prism) application
2. Drop a TSQLConnection component
3. Set the connection properties (3 in all)
4. Right-mouse click on the TSQLConnection and generate Client Proxy
5. Use Proxy to connect to the remote server and call logic at will
6. Expose information on client

Done

This is a nine minute demo with explanations, 5 without… at best and IMO, it is the fastest multi-tier approach out there compared to JEE, CORBA, RMI, COM/DCOM, or plain old RPC.

This approach isolates the database layer to the middle tier; there is no reason for the client to know that you are even connecting to a backend database. The exposure of business logic is as simple as writing public functions and the building of the actual server is a form and three (3) components. There are no 7 helper files like with Java’s EJB, or 3 helper files with CORBA, or IDL/RIDL with COM/DCOM, and you surely don’t have to define each side of the communication like with RPC.

So there must be a downside to the technology… there always is… isn’t there? As far as I can see today, there are no advert downsides. There is no royalty to use it, it is simple to understand, it helps to reduce database connections, it very fast, it scales well, and it uses open protocols. What is not to like?

Now could there be more features added or could it even become simpler to use in future releases of the feature/functionality? Sure, but then again, if you are a diehard Delphi/C++Builder developer you already know that we don’t rest on the past implementation we are always trying to push the technology to the next level.

This leads to the next item; I’m going to be publishing the roadmap for RAD Studio very soon and also an audio recording of the presentation. There will be more details about where the technology of DataSnap is going in the future and should give every Delphi/C++Builder/Prism developer some great piece of mind to see the investment being put into our beloved product with Embarcadero!

HelpNDoc let's you generate help files in various formats from a single source

2009-05-20T05:52:00.000-07:00

CHM: Compiled Microsoft Windows HTML Help;

HTML: Complete web help optimized for easy online browsing and search engines;

DOC: Complete help documentation as a Microsoft Word document or RTF file;

PDF: Standard Adobe portable document format documentation for easy sharing and printing;

HelpNDoc includes a complete WYSIWYG editor with advanced formatting and layout capabilities.

Advanced paragraph formatting: alignment, indentation, line spacing, tabs and text flow;

Advanced font customization: character spacing, offset, scaling, superscripts and subscripts;

Extensive image format support: JPG, PNG, GIF, BMP, ICO, EMF, WMF;

Advanced table support: cell padding and spacing, alignment, customizable borders and fills;

Complete live spell checker with custom dictionaries and automatic corrections;

Table of content editor with instant reorganization and customization;

Extremely fast topic creation, deletion and customization;

Advanced keywords editor: easily attach keywords with topics, categorize and manage them;

Automatic Topic ID and Context number generation;

Writing and integrating help files has never been easier thanks to HelpNDoc's advanced functionalities.

Live external document import: the document will be imported when the help file is generated;

Project or user defined variables: the variable will be replaced when the help file is generated;

Project-wide efficient find and replace tool: find a sentence and replace it by a variable;

Multiple language code generation: C/C++ headers, Delphi units, Visual Basic and Fortran modules to ease help file interaction;

Extensive command line support to pilot HelpNDoc from an external application, an automated processing or a batch script;

Delphi Prism Web Services and SOAP Security

2009-05-20T05:45:00.000-07:00

In this article, I'll demonstrate how to use SOAP Headers as security technique for ASP.NET Web Service projects using Delphi Prism (extending the example from last month by adding a security layer to it).

SOAP Headers

In order to work with SOAP Headers in an ASP.NET Web Service, we have to add System.Web.Services.Protocols to the uses clause, and define a new class derived from the SoapHeader class found in the aforementioned namespace.
The new class can be called anything, so I've decided to call it TCredentials (I know that in the .NET Framework you're not supposed to prefix everything with a "T", but since I'm a proud Delphi developer, I always use a T prefix for my types).

It must be a public class, since we need to export it so any client importing our ASP.NET web service can also know about it.
Adding a Username and Password field to the TCredentials class, this could lead to the following definition.


  type
    TCredentials = public class(System.Web.Services.Protocols.SoapHeader)
    public
      Username: String;
      Password: String;
    end;

With this class definition in mind, we can add a public field (for example called token) to the public class Service, as well as a private method (for example called CheckCredentials) to check if the credentials have been received and contain the correct username/password information.
This leads to the following modification of the Service class:


    Service = public class(System.Web.Services.WebService)
    public
      var
        token: TCredentials;

    private
      method CheckCredentials: Boolean;

In order to specify that the token has to be used for certain web method (from the original set), we have to add the attribute SoapHeader to the web method, specifying the token as well as the direction in which the token is assigned (in our case only on input, so only the web service client will be writing information in the token, and the Service web service "engine" can check the token for valid credentials by looking at its value).

Using the example from last month, we can modify some of the web methods as follows:


    public
      [WebMethod(EnableSession := true)]
      [SoapHeader('token', Direction := SoapHeaderDirection.&In)]
      method Remember(const Name,Value: String);

      [WebMethod(EnableSession := true)]
      [SoapHeader('token', Direction := SoapHeaderDirection.&In)]
      method Recall(const Name: String): String;

      [WebMethod(EnableSession := true)]
      method Forget(const Name: String);

      [WebMethod(EnableSession := true)]
      method Amnesia; // forget all
    end;

Note that I only added the SoapHeader attribute to the Remember and Recall web methods, and not to the Forget or Amnesia methods.
In other words: you are free to forget, but in order to remember or recall something, you need security clearance.

Inside that Remember and Recall methods, we will have to call the CheckCredentials method before doing their actual work, in order to verify the value of the token.
Which leads us to the implementation of CheckCredentials, which is shown below (using a hard-coded check for the values of the Username and Password properties of the token - you should obviously implement a stronger check here!).

Note that apart from returning False is the Username and Password are incorrect, we can also raise an exception, for example if the token is not found in the SOAP header (which might happen if the web service is consumed and used by web service client applications who do not add the token to the SOAP header in the first place).


  method Service.CheckCredentials: Boolean;
  begin
    Result := False;
    if not Assigned(token) then
        raise ApplicationException.Create('No token in SOAP Header!');

    if (token.Username.ToLower = 'bob') and
       (token.Password.ToLower = 'swart') then Result := True
  end;

The implementation of Remember and Recall can simple be extended by calling the CheckCredentials method before doing anything:


  method Service.Remember(const Name,Value: String);
  begin
    if CheckCredentials then
      Session[Name] := Value
  end;

  method Service.Recall(const Name: String): String;
  begin
    if CheckCredentials then
      if Assigned(Session[Name]) then
        Result := Session[Name].ToString
      else Result := ''
  end;

Note that Forget and Amnesia remain unchanged, since you are always allowed to forget:


  method Service.Forget(const Name: String);
  begin
    Session.Remove(Name) // always allowed
  end;

  method Service.Amnesia;
  begin
    Session.Abandon // always allowed
  end;

Before deploying and consuming this new secure web service, there's one thing to keep in mind about using SOAP Headers: the contents are sent in plain text over the network.
So passing a username and password inside a SOAP Header is adding authorization capabilities, but still lacks a little security.
For that reason, I always recommend to use SOAP Headers in combination with HTTPS and SSL.
That way, the traffic between the web service and client is encrypted, and nobody else should be able to decypher the information sent by the client to the server (since it's encrypted with the public key from the server, and can only be decrypted by the private key of the server, so anyone sniffing the network only gets an encrypted package).

Implementing HTTPS and SSL requires two things: first, you should purchase a certificate and install it on your web server (or ask your provider if a certificate is already available for use by your web service), and second, all URLs that are used to communicate with the web service should use https:// and not http://.

For this example, I give you the option of exploring the difference, so I've deployed the secure web service on two different web servers: one with HTTPS and one without.
On one server, you can access the web service via http://www.bobswart.net/MyWebService/Service.asmx and on the other (secure) web server you have to use HTTPS and the URL https://www.bobswart.nl/MyWebService/Service.asmx instead.

Both will work the same (the MyWebService.dll code behind assembly is exactly the same on both machines), but one connection is more secure than the other, which is important when using SOAP Headers.

Move TPageControl's Tabs Using Drag and Drop in Delphi Applications

2009-05-13T19:41:00.000-07:00

TPageControl is a set of pages used to make a multiple page dialog box. Why not enable your users to rearrange tabs in a TPageControl component at run-time using drag and drop...
Drop a TPageControl on a form, add several (tab) pages and handle the MouseDown, DragDrop and DragOver events of the TPageControl (PageControl1) component

Why not enable your users to rearrange tabs in a TPageControl component at run time using drag and drop...
Drop a TPageControl on a form, add several (tab) pages and handle the MouseDown, DragDrop and DragOver events of the TPageControl (PageControl1) component.

procedure TMainForm.PageControl1MouseDown(Sender: TObject;
Button: TMouseButton; Shift: TShiftState; X, Y: Integer) ;
begin
PageControl1.BeginDrag(False) ;
end;

procedure TMainForm.PageControl1DragDrop(Sender, Source: TObject; X,
Y: Integer) ;
const
TCM_GETITEMRECT = $130A;
var
TabRect: TRect;
j: Integer;
begin
if (Sender is TPageControl) then
for j := 0 to PageControl1.PageCount - 1 do
begin
PageControl1.Perform(TCM_GETITEMRECT, j, LParam(@TabRect)) ;
if PtInRect(TabRect, Point(X, Y)) then
begin
if PageControl1.ActivePage.PageIndex <> j then
PageControl1.ActivePage.PageIndex := j;
Exit;
end;
end;
end;

procedure TMainForm.PageControl1DragOver(Sender, Source: TObject; X,
Y: Integer; State: TDragState; var Accept: Boolean) ;
begin
if (Sender is TPageControl) then Accept := True;
end;

What is an Access Violation

2009-05-12T19:53:00.001-07:00

Every computer program uses memory for running (*). Memory is consumed by every variable in your program. It can be form, component, object, array, record, string or simple Integer. Memory can be allocated automatically for certain types of variables (such as Integer or static arrays), the other types require manual control of memory (for example, dynamic arrays). Essentially, from the point of operating system, each variable is characterized by its address (i.e. - location) and size.

Roughly speaking, program uses 3 “types” of memory: area for global variables, the stack and the heap.
Memory for global variables is allocated by OS loader when executable module is loading and it is freed when module is unloading. Global variables are those, which declared outside of class or any routine. The stack is used for allocating memory for local variables (which are declared in some function or procedure) and auxiliary data (such as return addresses or exception handlers). The heap is used for storing dynamic data.
Note, that for variables of dynamic types (such as dynamic arrays, strings, objects or components) - though the variable itself is stored in global area or stack, but its data is always allocated on the heap and it (often) require manual control.

Regardless of who allocates memory for the variable (you, manually or the compiler, automatically), memory for each variable must be allocated before its using, and later (when the variable is no longer needed) it should be freed.
Sometimes there can be a situation, where your application trying to get access to certain memory location, which wasn’t allocated or was already released - due to bugs in your code. When such things happens - the CPU raises an exception of class EAccessViolation. The usual text for this error is as follows: “Access violation at address XXX in module ‘YYY’. Write/read of address ZZZ”. Though there is the one simple reason for this kind of error, the real situations for it can be very different.

The server records for small business

2009-05-10T16:21:00.000-07:00

Usually the boss needs accurate reports on all divisions «here and now» – in such moments, there is neither time, nor means to acquire and implement big cooperative systems. But, there is an easy solution to such tasks.

Maybe, you had to undertake the installation of automatic systems at film level. Any such system must accumulate data, process it and give the result. Usually, there is already a working program support, which does all this, but when the data is accumulated, sometimes it happens that, the process is not enough and there isn’t the needed report. It is okay, if it’s possible to turn to the developer and ask to do everything, but this is not possible, if the program was installed a long time ago or was bought in a box .In this case, it is important to get a limited fast result which can satisfy the boss and will not be very expensive. The tools for IT development-infrastructure are now, as a rule, limited. But because of the automation, there is need to optimize the business process now, controlling it and as a result, future economy.

Often there is need to do a difficult job, collect data from several bases, connect them together,analyse it and give the result in a group, accessible for analysis and controlling. The data can be different – text file, data base in the formats DBF-file, electronic file table. It happens that, the similar task cannot be solved or needs a lot of money to develop a specific program. Here, one might refuse automation, or to creating a specific solution – using early operating time and collecting constructors from different program «blocks», collect everything from the module available at the market, do a minimum binding and build upon a certain task.

The company Fast Reports (fast-report.com) has got several program products on the market, which can substantially lessen the solution to the above given tasks. This is the very missing «block», which can handle the creation of reports and the given data in the needed form. The base to all these solutions, is a powerful report generator FastReport, which has shown itself to be dependable, fast and an easy solution for data processing. 11 years of successful work at the market has allowed the company to create an easy to use program product for information systems developers and users to create needed reports

One of FastReports flag products – Report server. It is a stand-alone HTTP-server, which can be installed on any computer on a local network under the MS Windows 2000 and above operating system. Apart from the function saving static files, it can process query concerning the creation of reports, including the prior entrance of data through web forms. The user receives the result in form of HTML-page, by using an ordinary web browser or the format needed by him, for example, PDF, Open Office, Rich Text и and many others. The printing function is accessible on any printer on the network, registered on the computer, where FastReport Server, works. Server settings are very easy. Generally, it is ready to be used immediately after installation. If on the computer, there is already a different web server installed, then, only changing the number of the working port and restarting FastReportServer, is needed. It is possible to work together with the already installed web servers like IIS and Apache with the help of the CGI- application or in form of ISAP-module which comes with the FastReport Server packet. Doing that makes the running of the individual servers unnecessary – all the functions of the report server will concentrate on ISAPI DLL. All the server settings will be saved in xml-file, supplying comments and can be changed with the help of the program-configuration. All reports, being done on the FastReport Server, are compatible with the FastReport 4 format and can be transferred from early developed programs, in which FastReport 4 was. The user can, develop his own reports with the help of the FastReport Studio, report designer. Trial version comes together with the server packet, and the license of FastReport Studio Single the buyer of server, receives as a present. It is important to note the possibility of FastReport to create several connections to the data base in one report and collect information from different data bases. Generally, any data can be used, accessible through ODBC-driver

Not long ago, Fast Reports released an update of its server solution. FastReport Server 2.1 has become stable and faster, improved the interaction with famous web servers like Microsoft IIS and Apache. The most important innovation became the possibility to use in the MS Windows authentication , which opens the possibility for a tight integration in the Active Directory domain and make simpler the running of records account and users group – each users group can form a report which it needs – managing – someone, accountant – another. And every user can be absolutely calm because of the accuracy of the information being received – the report will be formed on its query exactly at that moment, when it is needed!

Execute a Delphi Method (Procedure/Function) by Name

2009-05-09T18:26:00.001-07:00

When you need to convert an integer to a string, you would use the IntToStr Delphi function. When you need to display a form modally you would use the ShowModal method of a form object.

In short, functions, procedures and methods are called by their name. Ok, I know you knew that.

What if you need to call a function by its name as a string variable value? What if you need to use a code like:

ExecMethod(Form1, 'ShowModal');

type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject) ;
procedure CallMeByName(Sender: TObject) ;
private
procedure ExecMethod(OnObject: TObject; MethodName: string) ;
end;

var
Form1: TForm1;

type
TExec = procedure of object;

procedure TForm1.ExecMethod(OnObject: TObject; MethodName: string) ;
var
Routine: TMethod;
Exec: TExec;
begin
Routine.Data := Pointer(OnObject) ;
Routine.Code := OnObject.MethodAddress(MethodName) ;
if NOT Assigned(Routine.Code) then Exit;
Exec := TExec(Routine) ;
Exec;
end;

procedure TForm1.CallMeByName(Sender: TObject) ;
begin
ShowMessage('Hello Delphi!') ;
end;

procedure TForm1.Button1Click(Sender: TObject) ;
begin
ExecMethod(Form1, 'CallMeByName') ;
end;

How to Remove the "Today" Mark from the TDateTimePicker

2009-05-08T18:25:00.000-07:00

The TDateTimePicker component displays a list box for entering dates or times. By design it displays the label "today" at the bottom of the control allowing a user to quickly select the today's date.

Here's how to remove the "today" marker from the TDateTimePicker. Handle the OnDropDown event as:

uses CommCtrl, ...

procedure TForm1.DateTimePicker1DropDown(Sender: TObject) ;
var
wnd: HWND;
style: Integer;
begin
wnd := DateTime_GetMonthCal(DateTimePicker1.Handle) ;
if wnd <> 0 then
begin
style := GetWindowLong(wnd, GWL_STYLE) ;
SetWindowLong(wnd, GWL_STYLE, style or MCS_NOTODAY or MCS_NOTODAYCIRCLE) ;
end;
end;

Finalizing DelphiLive Material

2009-05-08T18:22:00.000-07:00

Well today I am putting the finishing touches on my DelphiLive presentations.

I will be presenting:

Power of the RTTI In Delphi
Moving from BDE to DBX

I have this love hate relationship with PowerPoint, sometimes I find its the best way to communication information. However as soon as things get technical I really dislike seeing a bunch of code on slides.

In My Power of the RTTI in Delphi Session I currently I have grand total of 3 Slides for this presentation the rest is code.

I will be covering:

Interacting with Published Information
Dynamic Method Invocation
Dynamic Class Creation
Ideas on how you might use it your applications.

In My BDE to DBX Session, I have several slides, but don't worry I have plenty of code and examples to show.

One of the things I like the best about this presentation won't come till near the end, but at the State of Utah we wrote a simple DFM parser and combined it with Martin Waldenburg Delphi Parser (TmwPasLex) and wrote a simple but effective conversion utility. It saved us tons of time when converting a BDE Application to DBX. The application we converted was not a simple demo program, It has 650+ DFMs. And several more units 500+ with no associated dfm. That does not count any third party code, or our own internally developed components.

I have updated the conversion utility to be slightly more generic as the original was specific to our needs. I will share that code with the attendees.

I hope to see you there!

UK firm splashes out to buy Borland and Compuware

2009-05-07T18:31:00.000-07:00

One of the grandees of the IT industry for the past 30 years, Borland Software, has been acquired by British software company Micro Focus International, in a cash deal worth £50 million ($75 million).

At the same time, Micro Focus said it is also acquiring the application testing and automated software quality business of Compuware Corporation for £53 million ($80 million).

Micro Focus said the two deals would give it a leading market position in the testing and automation market.

Borland was founded way back in 1981 by three Danish citizens, but soon moved to the United States where it was headed up by the flamboyant Philippe Kahn, who led the company for most of the 1980s and 1990s.

Borland developed a series of well-regarded software development tools during its existence, and is probably most associated with Turbo Pascal, Quattro Pro (spreadsheet), and Paradox (database). The company was also known for acquiring Ashton-Tate back in September 1991, a deal that netted it the dBase and InterBase databases, and for a time Borland was counted as a serious rival to both Microsoft and Oracle.

But it soon found itself squeezed by its rivals and in 1998, Borland changed its name to Inprise Corporation in an effort to appeal to the enterprise applications development market. The idea was to integrate Borland's tools, Delphi, C++ Builder, and JBuilder with enterprise environment software. But the move backfired, and in January 2001, the Inprise name was abandoned and the company reverted to the "Borland" name once more.

In February 2006 Borland announced the divestiture of its IDE division, including Delphi, JBuilder, and InterBase. At the same time it announced the planned acquisition of Segue Software, a maker of software test and quality tools. The spinoff was called CodeGear.

From 2007, Borland concentrated on Application Lifecycle Management (ALM) and in May 2008 it sold its CodeGear division to Embarcadero Technologies.

The deal to acquire Borland means that Micro Focus will expand its presence in the application testing market, where it already operates with its Data Express product.

"Micro Focus's proposed acquisition of Borland represents the next logical stage in Micro Focus's growth journey," said Stephen Kelly, CEO of Micro Focus, in a statement. "Our organic performance remains strong as reflected in our trading statement also released today, and this transaction will add new scale and breadth to further develop our customer proposition, in an attractive adjacent market to our existing business."

Newbury, Berkshire-based Micro Focus was founded back in the 1970s and is best known as a software provider that helps companies move older legacy software to more modern business systems.

The UK company is also acquiring the application testing and automated software quality business of Compuware for $80 million, again also in cash. Compuware made its name in the testing, development and management software for programs running on mainframe computer and client-server systems.

Micro Focus feels its products are "highly complementary to Micro Focus' core solutions as they address a logically adjacent portion of the software development and deployment value chain."

"Acquiring the Compuware Testing and ASQ business is a logical extension to our existing application management proposition, and we see strong growth potential in this market," said Kelly.

Both deals have been approved by the relevant boards, but still need shareholder and regulator approval. Micro Focus also said its group revenues for 2009 were expected to grow year on year by approximately 20 percent.

Silverpoint MultiInstaller

2009-05-07T18:28:00.001-07:00

Silverpoint MultiInstaller is a multi component package installer for CodeGear Delphi and C++Builder, it was created to ease the components installation on the IDE.

Silverpoint MultiInstaller can help you install multiple component packs in a few clicks.
Just download the zips and select the destination folder, all the components will be uninstalled from the IDE if they were previously installed, unziped, patched, compiled and installed on the Delphi IDE.

Getting Started
To install a component pack with MultiInstaller you have to follow these steps:
1) Read the licenses of the component packs you want to install.
2) Get the zip files of component packs.
3) Get the Silverpoint MultiInstaller.
4) Get the Setup.ini file for that component pack installation or create one.

class helper to get SourceFileName from an EAssertionFailed

2009-05-06T20:45:00.000-07:00

In one of our applications, we have a default Config.xml file that is in our source tree, but it can be overridden by a Config.xml file relative to the application’s .EXE file.

So we have a two step process looking for the Config.xml, and we’d like to have the full path to the source file where the sources were build.

It seems the only way to get that, is by looking inside the Message of an EAssertionFailed exception.

So I wrote yet another class helper to get this code to work:



function GetConfigPathName(const Application: TApplication): string; overload;
var
  TriedFileNames: IStringListWrapper;
  SourceFileName: string;
begin
  TriedFileNames := TStringListWrapper.Create();
  Result := FindConfigPathName(Application, TriedFileNames);
  try
    AssertConfigFileNameExists(Result, Application.ExeName, TriedFileNames);
  except
    on E: EAssertionFailed do
    begin
      SourceFileName := E.GetSourceFileName();
      Result := FindConfigPathName(SourceFileName, TriedFileNames);
      AssertConfigFileNameExists(Result, Application.ExeName, SourceFileName, TriedFileNames);
    end;
  end;
end;

Note the IStringListWrapper; I’ll get back to that in a later blog-post.

The full code of the class helper is right below.

Just a few remarks:

EAssertionFailed is in the SysUtils unit, and builds its Message by formatting a string using the SAssertError const in the SysConst unit as a mask.

We use that mask to “parse” the Message from right to left. Parsing from left to right is virtually impossible, as the first string is the assertion message itself, and we don’t know how that looks like.

If you are not using Delphi 2009, then replace the CharInSet call with a regular set check.



unit AssertionFailedHelperUnit;

interface

uses
  SysUtils;

type
  TAssertionFailedHelper = class helper for EAssertionFailed
  public
    function GetSourceFileName: string;
  end;

implementation

uses
  SysConst;

function TAssertionFailedHelper.GetSourceFileName: string;
var
  Mask: string;
  ExceptionMessage: string;
  OpeningParenthesesPosition: Integer;
begin
  //no valid configuration file found relative to C:\Program Files\CodeGear\RAD Studio\6.0\bin\bds.exe (C:\develop\ActiveMQDemo\common\src\ConfigHelperUnit.pas, line 84)
  //  SAssertError = '%s (%s, line %d)';
  // now create this string " (, line 0)" and use it to parse from right to left
  Mask := Format(SAssertError, ['', '', 0]);
  ExceptionMessage := Self.Message;
  // remove the closing ")"
  if (ExceptionMessage <> '') then
  begin
    Delete(ExceptionMessage, Length(ExceptionMessage), 1);
    Delete(Mask, Length(Mask), 1);
    // remove the "0" from the Mask
    Delete(Mask, Length(Mask), 1);
  end;
  while (ExceptionMessage <> '') and (CharInSet(ExceptionMessage[Length(ExceptionMessage)], ['0'..'9'])) do
    Delete(ExceptionMessage, Length(ExceptionMessage), 1);
  // from the right side, remove the ", line " portion
  while (ExceptionMessage <> '') and (ExceptionMessage[Length(ExceptionMessage)] = Mask[Length(Mask)]) do
  begin
    Delete(ExceptionMessage, Length(ExceptionMessage), 1);
    Delete(Mask, Length(Mask), 1);
  end;
  // now find the opening "("
  OpeningParenthesesPosition := Length(ExceptionMessage);
  while (ExceptionMessage <> '') and (ExceptionMessage[OpeningParenthesesPosition] <> '(') do
    Dec(OpeningParenthesesPosition);
  Delete(ExceptionMessage, 1, OpeningParenthesesPosition);
  Result := ExceptionMessage;
end;

end.

Understanding Delphi Project Files

2009-05-05T19:16:00.000-07:00

Since it is quite common for Delphi applications to share code or previously customized forms, Delphi organizes applications into what is called projects.

A project is made up of the visual interface along with the code that activates the interface. Each project can have multiple forms, allowing us to build applications that have multiple windows. The code that is needed for a form in our project is stored in a separate Unit file that Delphi automatically associates to the form. General code that we want to be shared by all the forms in our application is placed in unit files as well. Simply put, a Delphi project is a collection of files that make up an application.

What this means is that each project is made of one or more Form files (files with the .dfm extension) and one or more Unit files (.pas extension). We can also add resource files, and they are compiled into .RES files and linked when we compile the project.

Project File

Each project is made up of a single project file (.dpr). Project files contain directions for building an application. This is normally a set of simple routines which open the main form and any other forms that are set to be opened automatically and then starts the program by calling the Initialize, CreateForm and Run methods of the global Application object (which is actually a form of zero width and height, so it never actually appears on the screen).

Note: The global variable Application, of type TApplication, is in every Delphi Windows application. Application encapsulates your application as well as provides many functions that occur in the background of the program. For instance, Application would handle how you would call a help file from the menu of your program.

Project Unit

Use Project - View Source to display the project file for the current project.

Althogh you can look and edit the Project File, in most cases, you'll let Delphi maintain the DPR file. The main reason to view the project file is so we can see the units and forms that make up the project, and which form is specified as the application's main form.

Another reason to work with the project file is when we are creating a DLL rather than a stand-alone application or need some start-up code, such as a splash screen before the main form is created by Delphi.

Here is the default project file for a new application (containing one form: "Form1"):

program Project1;
uses
Forms,
Unit1 in 'Unit1.pas' {Form1};
{$R *.RES}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1) ;
Application.Run;
end.

The program keyword identifies this unit as a program's main source unit. You can see that the unit name, Project1, follows the program keyword (Delphi gives the project a default name until you save the project with a more meaningful name). When we run a project file from the IDE, Delphi uses the name of the Project file for the name of the EXE file that it creates.

Delphi reads the uses clause of the project file to determine which units are part of a project.

The .dpr file is linked with the .pas file with the compile directive {$R *.RES} (in this case ‘*’ represents the root of the .pas filename rather than "any file"). This compiler directive tells Delphi to include this project's resource file. The project's resource file contains such items as the project's icon image.

The begin..end block is the main source-code block for the project.

Although Initialize is the first method called in the main project source code, it is not the first code that is executed in an application. The application first executes the "initialization" section of all the units used by the application.

The Application.CreateForm statement loads the form specified in its argument. Delphi adds an Application.CreateForm statement to the project file for each form you add to the project. This code's job is to first allocate memory for the form. The statements are listed in the order the forms are added to the project. This is the order that the forms will be created in memory at runtime. If you want to change this order, do not edit the project source code. Use the ProjectOptions menu command.

The Application.Run statement starts your application. This instruction tells the predeclared object called Application to begin processing the events that occur during the run of a program.

An Example: Hide Main Form / Hide Taskbar Button

The Application object's ShowMainForm property determines whether or not a form will show at startup. The only condition of setting this property is that it has to be called before the Application.Run line.

//Presume: Form1 is the MAIN FORM
Application.CreateForm(TForm1, Form1) ;
Application.ShowMainForm := False;
Application.Run;

Design Your Delphi Program in a Way That it Keeps its Memory Usage in Check

2009-05-05T19:12:00.000-07:00

When writing long running applications - the kind of programs that will spend most of the day minimized to the task bar or system tray, it can become important not to let the program 'run away' with memory usage.

Learn how to clean up the memory used by your Delphi program using the SetProcessWorkingSetSize Windows API function.

Memory Usage of a Program / Application / Process

Take a look at the screen shot of the Windows Task Manager...

The two rightmost columns indicate CPU (time) usage and memory usage. If a process impacts on either of these severely, your system will slow down.

The kind of thing that frequently impacts on CPU usage is a program that is looping (ask any programmer that has forgotten to put a "read next" statement in a file processing loop). Those sorts of problems are usually quite easily corrected.

Memory usage on the other hand is not always apparent, and needs to be managed more than corrected. Assume for example that a capture type program is running.

This program is used right throughout the day, possibly for telephonic capture at a help desk, or for some other reason. It just doesn’t make sense to shut it down every twenty minutes and then start it up again. It’ll be used throughout the day, although at infrequent intervals.

If that program relies on some heavy internal processing, or has lots of art work on its forms, sooner or later its memory usage is going to grow, leaving less memory for other more frequent processes, pushing up the paging activity, and ultimately slowing down the computer.

How can I implement threads in my programs without using the VCL TThread object?

2009-05-04T20:08:00.000-07:00

I've done extensive work in multi-threaded applications. And in my experience, there
have been times when a particular program I'm writing should be written as a
multi-threaded application, but using the TThread object just seems like overkill.
For instance, I write a lot of single function programs; that is, the entire functionality
(beside the user interface portion) of the program is contained in one single execution
procedure or function. Usually, this procedure contains a looping mechanism (e.g. FOR,
WHILE, REPEAT) that operates on a table or an incredibly large text file (for me, that's
on the order of 500MB-plus!). Since it's just a single procedure, using a TThread
is just too much work for my preferences.

For those experienced Delphi programmers, you know what happens to the user interface
when you run a procedure with a loop in it: The application stops receiving messages.
The most simple way of dealing with this situation is to make a call to Application.ProcessMessages
within the body of the loop so that the application can still receive messages from
external sources. And in many, if not most, cases, this is a perfectly valid thing to do.
However, if some or perhaps even one of the steps within the loop take more than a couple
of seconds to complete processing — as in the case of a query — Application.ProcessMessages
is practically useless because the application will only receive messages at the time the
call is made. So what you ultimately achieve is intermittent response at best. Using a
thread, on the other hand, frees up the interface because the process is running
completely separate from the main thread of the program where the interface resides. So
regardless of what you execute within a loop that is running in a separate thread, your
interface will never get locked up.

Don't confuse the discussion above with multi-threaded user interfaces. What I'm
talking about is executing long background threads that won't lock up your user interface
while they run. This is an important distinction to make because it's not really
recommended to write multi-user interfaces, because each thread that is created in the
system has its own message queue. Thus, a message loop must be created to fetch messages
out of the queue so they can be dispatched appropriately. The TApplication object that
controls the UI would be the natural place to set up message loops for background threads,
but it's not set up to detect when other threads are executed. The gist of all this is
that the sole reason you create threads is to distribute processing of independent
tasks. Since the UI and controls are fairly integrated, threads just don't make sense here
because in order to make the separate threads work together, you have to synchronize them
to work in tandem, which practically defeats threading altogether!

I mentioned above that the TThread object is overkill for really simple threaded
stuff. This is strictly an opinion, but experience has made me lean that way. In any case,
what is the alternative to TThread in Delphi?

The solution isn't so much an alternative as it is going a bit more low-level into the
Windows API. I've said this several times before: The VCL is essentially one giant wrapper
around the Windows API and all its complexities. But fortunately for us, Delphi provides a
very easy way to access lower-level functionality beyond the wrapper interface with
which it comes. And even more fortunate for us, we can create threads using a simple
Windows API function called CreateThread to bypass the TThread object
altogether. As you'll see below, creating threads in this fashion is incredibly easy to
do.

Setting Yourself Up

There are two distinct steps for creating a thread: 1)Create the thread itself, then 2)
Provide a function that will act as the thread entry point. The thread function or thread
entry point is the function (actually the address of the function) that tells your
thread where to start.

Unlike a regular function, there are some specific requirements regarding the thread
function that you have to obey:

You can give the function any name you want, but it must be a function name (ie.
function MyThreadFunc)

The function must have a single formal parameter of type Pointer (I'll discuss
this below)

The function return type is always LongInt

Its declaration must always be preceded by the stdcall directive. This tells the
compiler that the function will be passing parameters in the standard Windows convention.

Whew! That seems like a lot but it's really not as complicated as it might seem from
the description above. Here's an example declaration:

function MyThreadFunc(Ptr : Pointer) : LongInt; stdcall;

That's it! Hope I didn't get you worried. The CreateThread call is a bit more
involved, but it too is not very complicated once you understand how to call it. Here's
its declaration, straight out of the help file:

function CreateThread
  (lpThreadAttributes: Pointer;    //Address of thread security attributes
  dwStackSize: DWORD;             //Thread stack size
  lpStartAddress: TFNThreadStartRoutine;//Address of the thread function
  lpParameter: Pointer;                 //Input parameter for the thread
  dwCreationFlags: DWORD;               //Creation flags
  var lpThreadId: DWORD):               //ThreadID reference
  THandle; stdcall;                     //Function returns a handle to the thread

This is not as complicated as it seems. First of all, you rarely have to set security
attributes, so that can be set to nil. Secondly, in most cases, your stack size can
be 0 (actually, I've never found an instance where I have to set this to a value higher
than zero). You can optionally pass a parameter through the lpParameter argument as
a pointer to a structure or address of a variable, but I've usually opted to use global
variables instead (I know, this breaking a cardinal rule of structured programming, but it
sure eases things). Lastly, I've rarely had to set creation flags unless I want my thread
to start in a suspended state so I can do some preprocessing. For the most part, I set
this value as zero.

Now that I've thoroughly confused you, let's look at an example function that creates a
thread:


procedure TForm1.Button1Click(Sender: TObject);
var
  thr : THandle;
  thrID : DWORD;
begin
  FldName := ListBox1.Items[ListBox1.ItemIndex];
  thr := CreateThread(nil, 0, @CreateRecID, nil, 0, thrID);
  if (thr = 0) then
    ShowMessage('Thread not created');
end;

Embarrassingly simple, right? It is. To make the thread in the function above, I
declared two variables, thr and thrID, which stand for the handle of the
thread and its identifier, respectively. I set a global variable that the thread function
will access immediately before the call to CreateThread, then make the declaration,
assigning the return value of the function to thr and inputting the address of my
thread function, and the thread ID variable. The rest of the parameters I set to nil or 0.
Not much to it.

Notice that the procedure that actually makes the call is an OnClick handler for a
button on a form. You can pretty much create a thread anywhere in your code as long as you
set up properly. Here's the entire unit code for my program; you can use it for a
template. This program is actually fairly simple. It adds an incremental numeric key value
to a table called RecID, based on the record number (which makes things really easy).
Browse the code; we'll discuss it below:


unit main;

interface

uses
  Windows, Messages, SysUtils, Classes,
  Graphics, Controls, Forms, Dialogs, DB, DBTables, StdCtrls, ComCtrls,
  Buttons;

type
  TForm1 = class(TForm)
    Edit1: TEdit;
    Label1: TLabel;
    OpenDialog1: TOpenDialog;
    SpeedButton1: TSpeedButton;
    Label2: TLabel;
    StatusBar1: TStatusBar;
    Button1: TButton;
    ListBox1: TListBox;
    procedure SpeedButton1Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  end;

var
  Form1: TForm1;
  TblName : String;
  FldName : String;

implementation

{$R *.DFM}

function CreateRecID(P : Pointer) : LongInt; stdcall;
var
  tbl : TTable;
  I   : Integer;
  ses : TSession;
  msg : String;
begin
  Randomize; //Initialize random number generator
  I := 0;
  {Disable the Execute button so another thread can't be executed
   while this one is running}
  EnableWindow(Form1.Button1.Handle, False);          

  {If you're going to access any data in a thread, you have to create a
   separate }
  ses := TSession.Create(Application);
  ses.SessionName := 'MyRHSRecIDSession' + IntToStr(Random(1000));

  tbl := TTable.Create(Application);
  with tbl do begin
    Active := False;
    SessionName := ses.SessionName;
    DatabaseName := ExtractFilePath(TblName); //TblName is a global variable set
    TableName := ExtractFileName(TblName);      //in the SpeedButton's OnClick handler
    Open;
    First;
    try
          {Start looping structure}
      while NOT EOF do begin
        if (State <> dsEdit) then
          Edit;
        msg := 'Record ' + IntToStr(RecNo) + ' of ' + IntToStr(RecordCount);
                {Display message in status bar}
        SendMessage(Form1.StatusBar1.Handle, WM_SETTEXT, 0, LongInt(PChar(msg)));
        FieldByName(FldName).AsInteger := RecNo;
        Next;
      end;
    finally
      Free;
      ses.Free;
      EnableWindow(Form1.Button1.Handle, True);
    end;
  end;
  msg := 'Operation Complete!';
  SendMessage(Form1.StatusBar1.Handle, WM_SETTEXT, 0, LongInt(PChar(msg)));
end;

procedure TForm1.SpeedButton1Click(Sender: TObject);
var
  tbl : TTable;
  I : Integer;
begin
  with OpenDialog1 do
    if Execute then begin
      Edit1.Text := FileName;
      TblName := FileName;
      tbl := TTable.Create(Application);
      with tbl do begin
        Active := False;
        DatabaseName := ExtractFilePath(TblName);
        TableName := ExtractFileName(TblName);
        Open;
        LockWindowUpdate(Self.Handle);
        for I := 0 to FieldCount - 1 do begin
          ListBox1.Items.Add(Fields[I].FieldName);
        end;
        LockWindowUpdate(0);
        Free;
      end;
    end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  thr : THandle;
  thrID : DWORD;
begin
  FldName := ListBox1.Items[ListBox1.ItemIndex];
  thr := CreateThread(nil, 0, @CreateRecID, nil, 0, thrID);
  if (thr = 0) then
    ShowMessage('Thread not created');
end;

end.

The most important function here, obviously, is the thread function, CreateRecID.
Let's take a look at it:


function CreateRecID(P : Pointer) : LongInt; stdcall;
var
  tbl : TTable;
  I   : Integer;
  ses : TSession;
  msg : String;
begin
  Randomize; //Initialize random number generator
  I := 0;
  {Disable the Execute button so another thread can't be executed
   while this one is running}
  EnableWindow(Form1.Button1.Handle, False);          

  {If you're going to access any data in a thread, you have to create a
   separate }
  ses := TSession.Create(Application);
  ses.SessionName := 'MyRHSRecIDSession' + IntToStr(Random(1000));

  tbl := TTable.Create(Application);
  with tbl do begin
    Active := False;
    SessionName := ses.SessionName;
    DatabaseName := ExtractFilePath(TblName); //TblName is a global variable set
    TableName := ExtractFileName(TblName);      //in the SpeedButton's OnClick handler
    Open;
    First;
    try
          {Start looping structure}
      while NOT EOF do begin
        if (State <> dsEdit) then
          Edit;
        msg := 'Record ' + IntToStr(RecNo) + ' of ' + IntToStr(RecordCount);
                {Display message in status bar}
        SendMessage(Form1.StatusBar1.Handle, WM_SETTEXT, 0, LongInt(PChar(msg)));
        FieldByName(FldName).AsInteger := RecNo;
        Next;
      end;
    finally
      Free;
      ses.Free;
      EnableWindow(Form1.Button1.Handle, True);
    end;
  end;
  msg := 'Operation Complete!';
  SendMessage(Form1.StatusBar1.Handle, WM_SETTEXT, 0, LongInt(PChar(msg)));
end;

This is a pretty basic function. I'll leave it up to you to follow the flow of
execution. However, let's look at some very interesting things that are happening in the
thread function.

First of all, notice that I created a TSession object before I created the table I was
going to access. This is to ensure that the program will behave itself with the BDE. This
is required any time you access a table or other data source from within the context of a
thread. I've explained this in more detail in another article called How
Can I Run Queries in Threads? Directly above that, I made a call to the Windows
API function EnableWindow to disable the button that executes the code. I had to do
this because since the VCL is not thread-safe, there's no guarantee I'd be able to
successfully access the button's Enabled property safely. So I had to disable it
using the Windows API call that performs enabling and disabling of controls.

Moving on, notice how I update the caption of a status bar that's on the bottom of the
my form. First, I set the value of a text variable to the message I want displayed:


msg := 'Record ' + IntToStr(RecNo) + ' of ' + IntToStr(RecordCount);

Then I do a SendMessage, sending the WM_SETTEXT message to the status bar:


SendMessage(Form1.StatusBar1.Handle, WM_SETTEXT, 0, LongInt(PChar(msg)));

SendMessage will send a message directly to a control and bypass the window
procedure of the form that owns it.

Why did I go to all this trouble? For the very same reason that I used EnableWindow
for the button that creates the thread. But unfortunately, unlike the single call to EnableWindow,
there's no other way to set the text of a control other than sending it the WM_SETTEXT
message.

The point to all this sneaking behind the VCL is that for the most part, it's not safe
to access VCL properties or procedures in threads. In fact, the objects that are
particularly dangerous to access from threads are those descended from TComponent. These
comprise a large part of the VCL, so in cases where you have to perform some interaction
with them from a thread, you'll have to use a roundabout method. But as you can see from
the code above, it's not all that difficult.

Of the thousands of functions in the Windows API, CreateThread is one of the
most simple and straightforward. I spent a lot of time explaining things here, but there's
a lot of ground I didn't cover. Use this example as a template for your thread
exploration. Once you get the hang of it, you'll use threads in practically everything you
do.

Get the Url of a Hyperlink when the Mouse moves Over a TWebBrowser Document

2009-05-03T18:24:00.000-07:00

The TWebBrowser Delphi component provides access to the Web browser functionality from your Delphi applications.

In most situations you use the TWebBrowser to display HTML documents to the user - thus creating your own version of the (Internet Explorer) Web browser. Note that the TWebBrowser can also display Word documents, for example.

A very nice feature of a Browser is to display link information, for example, in the status bar, when the mouse hovers over a link in a document.

The TWebBrowser does not expose an event like "OnMouseMove". Even if such an event would exist it would be fired for the TWebBrowser component - NOT for the document being displayed inside the TWebBrowser.

In order to provide such information (and much more, as you will see in a moment) in your Delphi application using the TWebBrowser component, a technique called "events sinking" must be implemeted.

WebBrowser Event Sink

To navigate to a web page using the TWebBrowser component you call the Navigate method. The Document property of the TWebBrowser returns an IHTMLDocument2 value (for web documents). This interface is used to retrieve information about a document, to examine and modify the HTML elements and text within the document, and to process related events.

To get the "href" attribute (link) of an "a" tag inside a document, while the mouse hovers over a document, you need to react on the "onmousemove" event of the IHTMLDocument2.

Here are the steps to sink events for the currently loaded document:

Sink the WebBrowser control's events in the DocumentComplete event raised by the TWebBrowser. This event is fired when the document is fully loaded into the Web Browser.
Inside DocumentComplete, retrieve the WebBrowser's document object and sink the HtmlDocumentEvents interface.
Handle the event you are interested in.
Clear the sink in the in BeforeNavigate2 - that is when the new document is loaded in the Web Browser.

HTML Document OnMouseMove

Since we are interested in the HREF attribute of an A element - in order to show the URL of a link the mouse is over, we will sink the "onmousemove" event.

The procedure to get the tag (and its attributes) "below" the mouse can be defined as:

var
htmlDoc : IHTMLDocument2;

...
procedure TForm1.Document_OnMouseOver;
var
element : IHTMLElement;
begin
if htmlDoc = nil then Exit;

element := htmlDoc.parentWindow.event.srcElement;

elementInfo.Clear;

if LowerCase(element.tagName) = 'a' then
begin
ShowMessage('Link, HREF : ' + element.getAttribute('href',0)]) ;
end
else if LowerCase(element.tagName) = 'img' then
begin
ShowMessage('IMAGE, SRC : ' + element.getAttribute('src',0)]) ;
end
else
begin
elementInfo.Lines.Add(Format('TAG : %s',[element.tagName])) ;
end;
end; (*Document_OnMouseOver*)

As explained above, we attach to the onmousemove event of a document in the OnDocumentComplete event of a TWebBrowser:

procedure TForm1.WebBrowser1DocumentComplete( ASender: TObject;
const pDisp: IDispatch;
var URL: OleVariant) ;
begin
if Assigned(WebBrowser1.Document) then
begin
htmlDoc := WebBrowser1.Document as IHTMLDocument2;

htmlDoc.onmouseover := (TEventObject.Create(Document_OnMouseOver) as IDispatch) ;
end;
end; (*WebBrowser1DocumentComplete*)

And this is where the problems arise! As you might guess the "onmousemove" event is *not* a usual event - as are those we are used to work with in Delphi.

The "onmousemove" expects a pointer to a variable of type VARIANT of type VT_DISPATCH that receives the IDispatch interface of an object with a default method that is invoked when the event occurs.

In order to attach a Delphi procedure to "onmousemove" you need to create a wrapper that implements IDispatch and raises your event in its Invoke method.

Here's the TEventObject interface:

TEventObject = class(TInterfacedObject, IDispatch)
private
FOnEvent: TObjectProcedure;
protected
function GetTypeInfoCount(out Count: Integer): HResult; stdcall;
function GetTypeInfo(Index, LocaleID: Integer; out TypeInfo): HResult; stdcall;
function GetIDsOfNames(const IID: TGUID; Names: Pointer; NameCount, LocaleID: Integer; DispIDs: Pointer): HResult; stdcall;
function Invoke(DispID: Integer; const IID: TGUID; LocaleID: Integer; Flags: Word; var Params; VarResult, ExcepInfo, ArgErr: Pointer): HResult; stdcall;
public
constructor Create(const OnEvent: TObjectProcedure) ;
property OnEvent: TObjectProcedure read FOnEvent write FOnEvent;
end;

TMS Advanced Toolbars & Menus v3.7.5.0

2009-04-30T18:31:00.000-07:00

What's new & improved in version 3.7.5.0 New : SubMenuCaptionFont added in AdvPreviewMenu styler to have different title & caption font
New : PagerCaption.TextColorExtended added to allow to set different font for appname/docname in Window caption
New : Text property to put text on top of the shapebutton image
Improved : dropdown arrow on left docked toolbars painted in right direction
Improved : glass frame drawing on Windows Vista with Aero theme
Various smaller fixes & code improvements
All toolbar/ribbon components are also included in TMS Component Pack

How do you improve Quality

2009-04-30T18:28:00.000-07:00

There typically are 3 types of projects, when it comes to quality that I have seen.

The focus is getting the code out the door and then you pick up the pieces.
The focus is on getting quality code out the door until deadline nears then you revert to number 1.
The focus is on getting quality code out the door and as deadline nears features may be dropped and the deadline may slip.

When the project starts everyone seems to be on board with the idea of #3 but typically I have seen it slip all the way to #1 quite quickly.

At my current employer we have an internal application that is used by 300+ end users.

We used to have:

ZERO people dedicated to QA. (4-5 Delphi Developers, 1 Mainframe Programmer, no analysts)
Testing was done by end users testing as they had time.
We had no automated or unit tests.
The build process was compile from your own machine and copy it the network, with any developer free to release any code they wanted. Which would sometimes step over the other developers uncommitted code.
We had two environment's

Development used by both developers and testing.
Production

Exceptions had no details or context to help track down problems.
We had a very small and painful bug tracking system.
We would commonly be related to #1 type model above.

Over the few years that I have been here we have made many changes.
We now have:

We now have three people dedicated to QA. ( 7 Delphi Developers, 1 Database PL/SQL developer, and 1 Analyst)
We have end users still testing with the time that they have. But we now have better management support to get additional time needed.
We have a few automated tests, and a few more unit tests, but we really could use many more.
Our build process runs every hour through Final Builder, alerting us with email when someone checks in bad code.
We now have 4 environment's

Development (Dedicated to Developers only)
TEST where users get first look
QA a final look before production usually with data refreshed from production
Production.

We now use the JCL Debug to help use find those Hard to Reproduce Errors.
We have a better bug tracking system, but still not nearly as nice as some of the home grown solutions I have used at past employers.
We are now some where between the #2 and #3 model's above.

Every release we ask what can we do better? We try to learn from our mistakes and implement solutions to prevent problems. We release a new version of our software nearly every month, so we are continually improving, and quality has improved in many ways in the past few years.

However, today I feel awful!

We put out a release on Friday morning last week. I don't think I have ever had a release go bad as this one has. Today we are still working on fixing major problems that were caused by the release.

Some of which would have been caught by better testing.
Some of which would have been caught by better management of the information coming in about problems. (i.e. it was reported but not acted on!) Since, I usually manage this information, it's the reason I feel awful.
Of course like all systems some of them would have taken an unreasonable amount of testing to find.

So I have been thinking, it's time to go back to and look at quality in new and different ways.

I have been making a list for a while that specific to our product on ways to improve quality. Several items on the list are general enough to share with others.

Build a health check system detects common/possible problems that can be run daily in each environment's, which is very database specific. We have scripts for all of these, but not an automated way to run them.

Tables without primary keys
Missing Synonyms
Invalid Synonyms
Tables without indexes
Missing Grants
Disabled Constraints in Oracle
Tables that have not been analyzed recently.
FK Constraints without index on child table (table level lock will be placed on the parent table if these are found)
Invalid Database Objects
Plus several that are specific to our schema, i.e. constraints that can't be described in meta data.

Error Messages (Exceptions)
- Ability to Send error messages to a web service
- Ability to capture a screen shot with the error message.
- Ability to ask users what they are doing when the exception occurred.
- Ability to attach reported errors to items in bug tracking system.
Code Review to help identify and build additional unit tests around the code.
Automated Performance Testing Benchmark system. (I think DUnit has something that will work for us)
Get current Delphi Unit tests into an daily build and smoke test instead of just being run by hand by developers.

Ok...

I have shared some of my ideas on how to improve quality, as well as some of the things we have done.

How have you improved Quality in the software you write?

I am open to any suggestions, this is just a small attempt to think out side of the box.

Since I just started this blog, I really hope that someone is reading this and has some good ideas they are willing to share.

Code Beautifier Collection 6 for CodeGear RAD Studio 2007 is an open source expert

2009-04-29T20:54:00.001-07:00

Special Tip
The 7.0 series code named CandyCan is under development. A milestone will be provided soon.
History
Since its birthday in May, 2005, it has served hundreds of C#Builder 1.0, Delphi 8 for .NET, Delphi 2005, and Delphi 2006 users. Because RAD Studio 2007 (including Delphi 2007 and C++Builder 2007) is built on .NET 2.0 platform, 5.x generation support and update is discontinued and here comes a new 6.0 generation, which fully takes advantage of .NET 2.0 platform.
Notice
After installation, you can read the user manual (manual.pdf) to know more about Code Beautifier Collection and how it can improve your Delphi coding experience.

DeHL 0.3 is out

2009-04-29T20:44:00.000-07:00

I’m proud to announce the 0.3 version of DeHL library. This release focused on bug-fixes and extensions to type support engine. This version should pretty much stabilize what I started and should leave me more time to extend other interesting parts of the library such as collections.

For those who are new, DeHL is a project of mine designed to fill in some holes in the Delphi’s RTL — most notably, some centralized and OOP-ish Date/Time support, more generic collection classes and “big integer” math support. DeHL also builds up a new layer of “type support” which is very useful to abstract all type management tasks in generic classes. This projects only supports Delphi 2009 (and above) since Generics, Anonymous methods, and Unicode are widely used whithin the library. So even if you are not interested in the library itself, it may prove a good read if you are interested in all new features Delphi 2009 has to offer.

New features:

Type support classes now expose methods to convert a type from an to a Variant.

Based on the newly added Variant conversion, a new type: TConverter<T1, T2> is present. You can use it to support “blind” conversion in a class.

Much improved type support system
- Now more functionality is split between generic and non-generic variants of the type support classes (IType, IType<T>, TType, TType<T>).
- TypeSupport has been renamed to TType and IType repectively.
- IType/TType now export Name, Size, Management, TypeInfo and Family properties. You can use those properties to get more information about your generic type.
- Custom type registration has been improved. A new cleaner API can be used to register you custom types into the DeHL’s type system.
- TType<T>.Default is now an overloaded function. The first form is the usual one. The second form receives a set of “type families” that are expected to represent the generic type. This way you can effectively impose run-time type restrictions.
- TClassType is now generic with T being class-restricted. This allows to avoid compile-time type incompatibilities.

All important standard types in Delphi are now supported. This support required the working custom types system, since these types can’t be handled “by default“:
- Boolean, ByteBool, WordBool, LongBool
- TDateTime, TTime, TDate
- NativeInt, NativeUInt
- Real
- OleVariant
- UCS4Char, UCS4String
- UTF8String
- RawByteString

Bug fixes:

Fixed a bug in BigCardinal and BigInteger variant types related to string conversion.

A few changes in TDictionary to avoid compiler problems.

In a multi-threaded environment, the custom type support would not unlock properly leading to a dead-lock.

Cleanup routines for TDictionary and THashSet were flawed since those used FillChar to clear the array. Managed types had problems with that.

Char type support class now acts properly.

Note: It may be possible that the Testing project will not compile due to a bug in the Delphi compiler. But that should not prevent the usage of the library itself.

Steganography with Delphi - Hide Data Inside Images

2009-04-28T19:59:00.000-07:00

According to Wikipedia, Steganography is "the art and science of writing hidden messages in such a way that no-one, apart from the sender and intended recipient, suspects the existence of the message, a form of security through obscurity".

In computer terms, steganography means hiding a message within a larger one in such a way that others cannot see the presence or contents of the hidden message.

Interested in how to code a Delphi application to hide data inside an image using cryptography - steganography?

StegaImage - Steganography with Delphi
StegaImage is a little Delphi application to hide files (information) inside crypted images.
Take a file, hide it inside a BMP image, and that's all. All you get is a new image that looks like the original, but it has the data hidden inside it.

How does StegaImage work?
In a 24-bit bitmap, each pixel is made up of a 24-bit number. Each number is composed of three 8-bit numbers (the R, G and B channels). These are the intensity of the Red, Green and Blue colors that create the final color of the pixel.
To hide something inside the image, we will replace the Least Significant Bit (this is, the "rightmost" bit) of each 8-bit channel of every pixel, with the bits of the file we want to hide.

The image will lose some quality because now the colors of the pixels are not the same, but it will go unnoticed to the human eye.

Obviously, since we are storing only 3 bits per pixel, the image must have a phenomenal size to accommodate just a tiny little file.

For example, if we want to hide 1 MB of data, we need an image with 2,796,203 pixels, which would have a size of something like 2,200 x 1,320 pixels. And that is a 8.3 MB file!
We could replace the 2, 3 or 4 rightmost bits of every channel in order to increase the amount of data we can hide, but the quality could decrease considerably.
Try 8 bits per channel and you'll see what I'm talking about (amazingly, 7 normally produces intelligible - although very ugly- images).

Why should you always use FreeAndNil instead of Free

2009-04-28T19:19:00.000-07:00

Well, when someone talks about object creation and destruction, he usually imagine something like this:

However, I want to show that you should avoid “Free” call, whenever possible - by replacing it with call to FreeAndNil, for example:

Please, note, that I mean replacing Free -> FreeAndNil everywhere. I talk not about just using FreeAndNil, when you want to use “Assigned(SomeObj)”, but I really mean everywhere - by do not using Free at all. Yes, including cases with local variables.

Why? The reason is simple: there is no reason for not-doing it. And this post explains why it is so.

When you tell this to common Delphi developer, there are high chances that he’ll vote against it, saying:

1. Free + nil is not full equivalent of FreeAndNil. FreeAndNil clear pointer first and calls destructor second. If your code uses this reference - it will no longer work. For example, if we clear class field, but some internal class uses it during destruction process.

Well, I count it as advantage. It helps to catch bad-design. Because you just described a case, when your code either uses variable instead of Self (i.e. Form1.SomeObj instead of SomeObj) or accesses a partial-constructed object (actually, it is more like partially deleted object now). And by using FreeAndNil you can catch these cases.

Yes, such situations can be made “by-design”, but even so - you will detect an error immediately (obviosly, there will be Access Violation), so you can revert changes back, if you don’t want to redesign your code.

2. So what are examples of righteous/warrantable usage of FreeAndNil?

Hmm, it is not very clear, what example can be provided here. Excluding complicated examples (like in previous block), your code will work the very same way - with or without FreeAndNil. Replacing Free -> FreeAndNil - it is a pure optional action.

You can compare FreeAndNil with seat (safety) belts in cars: if you application runs normally - then FreeAndNil won’t be useful. But if your code mess up with something - then FreeAndNil (as seat belts too) will protect you from consequences. By clearing the reference, FreeAndNil will help you to catch your wrong access immediately. Without it (i.e. by using Free only), your code may continue to run (even without raising an exception) and gave the wrong results or damage global state. It is quite dangerous.

Note, that FreeAndNil is still not enough to fully cover those bad cases - because you can access one object through multiply variables. FreeAndNil will clear one reference, but it won’t touch others. A good example here is all kinds of lists of objects.

3. There is no need for FreeAndNil here! (i.e.: local variables)

Well, local variable can be refactored into global later. FreeAndNil will protect you from misuses (just Free is not). Large amount of code is done by using copy-paste. That is why someone can pick your code, copy it into another place (where variable has different scope or is used multiply times), then he’ll be in trouble - if you didn’t use FreeAndNil (and this “he” may be even you, but few months later). Besides, if you have large routine then you may just not notice, that you have used variable few times (for example - in cycle). By always using FreeAndNil you’ll make your code bullet-proof for modifications.

Moreover, it is just convient, when you have FreeAndNil everywhere, instead of mix of Free/FreeAndNil. And you don’t even need to think about it: “gosh, should I put FreeAndNil here or just Free is enough?!!”.

If you think that FreeAndNil is still overkill in certain case - then why don’t you use Destroy call? Indeed, the Free is overkill in many situations too!

Note, that object’s destructor is not called in 99% of Delphi’s code (a call to procedure is used instead). Then why don’t we take a step further and don’t use FreeAndNil instead? The benefit of using FreeAndNil is far greater then benefit from using Free instead of Destroy. Why? Well, if the first case we got the protection from very tricky mistakes (like I said - it is not panacea, but still a good bonus). And in the second case you got only ability to skip writing additional “if”. Why? Because if you call Destroy for nil-variable, you’ll get an AV immediately (because Self = nil, so any access to object’s field will trigger an undoubted AV). So, there is no problem at all - you will fix the code instantly. Compare this with case, when your code silently produce wrong results!

Furthermore, you can not giveup for a bonus “less writing” by implementing a routine “F”, which simply calls FreeAndNil.

4. Using Free instead of Destroy is recommended by CodeGear! And I never heard of such recommendation for FreeAndNil.

Well, we already examined arguments that Free -> FreeAndNil transition will have more benefits than (already happened) transition Destroy -> Free. Now, don’t you think that argument of not having official approval from CG does look quite dull?

5. Nevertheless, majority of people (who heard about this idea) will continue to claim that this is still overkill.

Why?

The most called reason is the force of the habit: “I write Free automatically, even without thinking”.

Well, actually, this argument is quite serious.

By in this post, I want to show you that there are good reasons to reconsider/change this habbit. Of course, there should be a really good reson for broking your habbits. And here it comes…

6. Safety of your code.

Many people says (and they, indeed, believe so) that experienced programmer can use FreeAndNil only in nessesary places. In all other cases there is no need to clear the object’s reference - so you can use Free.

But that is so wrong: you can not know that.

Imagine, that destructor of your object deletes its object-field by using Free (such common action, right?). The destructor for this sub-object calls a virtual method as part of its destruction process. This method can be empty in base class. Well, so far so good.

Now, someone (or may be you, few months later) will take these classes and override this virtual method. Now he will call another (virtual) method, which belongs to your first mentioned object. And this method (may be also in yet another child class) will try to use already deleted field in your first object. Suppose that this access will run ok (i.e. memory manager do not release this memory yet), but the global state of the application will be damaged forever. Ooops.

FreeAndNil will guard you from this situation (by raising 100% AV), and Free is not.

Why did I mention virtual methods here? That is why you cann’t say: “I know what I am doing - there is no need for FreeAndNil here”. As you can see - you can not know that! Yes, two of your base classes is all good with it, but the very usual code in child classes can lead to the darkest error in the entire class hierarchy. Yes, it is not actually your fault (unless you are also responsible for child classes too), but shouldn’t your code be ideal? And, yes, there is a bug in child class (by calling inadmissible method), but how will you catch it? Without FreeAndNil it is very hard to do.

Okay, even if you still insist on putting FreeAndNil only, when it is nessesary - then we just gave an example, when it is simply not obvious. If you have a habbit of using Free, then you can not even think about considering this case as worth adding FreeAndNil! That is where all problems come. You’ll just put Free call here (as usual) and go somewhere else. And then spend a few days for debugging this tiny, nasty problem later.

By using FreeAndNil everywhere you’ll dispose those problems (should I put it there or not?) - just put it everywhere! Like I said: FreeAndNil - is a safety belts. And realizing it is the only thing left.

Summary: from my point of view - the bonus of protection against fickle/implicit errors outweigh the need to change the habbit.

So.

Why wait? Why don’t use FreeAndNil everywhere, starting today? If you’ll make this your habbit - then you lose nothing, but gain very powerful bonus.

Nevertheless, I suspect that many Delphi programmers, even if they admit this idea, won’t change their practice - just because “someone has said something”. They do not meet with this situation - then it do not exists. So they’ll wait until the bug strike them hard. I’ll repeat it again: FreeAndNil is a safety belt. It protect you from bugs, that not happens yet.

Remark: this long post is just my opinion - feel free to reject it, if you (still) don’t like it.

When you reference an object via more than one reference, you can mistakenly use already disposed object or free the very same object twice. The FreeAndNil gives you protection only if you mistakenly use the object after its dispose, when you have only one reference.

So, even if you use FreeAndNil, you still need an additional checks. And if you have large project and suddenly changes all Free calls to FreeAndNil - then there are good chances then you’ll run into problems. You’ll probably detect many kind of misuses. To track down these problems you’ll need a tool.

Such checks can be found in EurekaLog. We will talk about its memory-related features in more details later (yes, about FastMM too), and now I want to give only brief overview.

Once enabled, this feature can detect a various memory misuse cases and report them through usual exception notification process in EL. Those cases includes double-free and writes to already freed memory. Similar features are very common in advanced memory managers (like FastMM, for example).

It is quite powerful feature, but just don’t forget that EurekaLog is a debugging tool. It is not essential part of Delphi language. You should not write code, which relies on its presence. I.e. you should not forget about FreeAndNil, hoping that EurekaLog will handle all bad cases for you. Besides, there still can be complex (and, actually, rare) situations, when EurekaLog’s features can not catch attempt of invalid memory access (it is not limitation of EL, the same is correct for other tools too). More on this topic later.

Apart from using FreeAndNil and diagnostic features in EurekaLog or MM, you should try to minimize references to each objects and try to use some sort of automatic management. For example, if your object can be included in the list, then it is good to add code, which removes object from any list it belongs to on deletion (there is an example in VCL - it is Components list-property).

Another approach is using interfaces with reference counting. Well, actually, you should be careful there: if you mix manual control of life-time (manual call to destructor) and automatic control (using reference counting in interfaces) - then things will go from bad to worse. But if you use only pure interfaces, then you’ll automatically get rid of such errors: compiler (well, your application at runtime) will look after your objects, not allowing their misuses.

Storing Resource (WAV, MP3, ...) into Delphi Executables

2009-04-27T17:10:00.000-07:00

Games and other types of applications which use multimedia files like sounds and animations must either distribute the extra multimedia files along with the application or embed the files within the executable.
Rather than distribute separate files for your application's use, you can add the raw data to your application as a resource. You can then retrieve the data from your application when it is needed. This technique is generally more desirable because it can keep others from manipulating those add-in files.

This article will show you how to embed (and use) sound files, video clips, animations and more generally any kind of binary files in a Delphi executable. For the most general purpose you'll see how to put a MP3 file inside a Delphi exe.

Resource Files (.RES)

In the "Resource Files Made Easy" article you were presented with several examples of the use of bitmaps, icons and cursors from resources. As stated in that article we can use the Image Editor to create and edit resources that consist of such types of files. Now, when we are interested in storing various types of (binary) files inside a Delphi executable we'll have to deal with resource script files (.rc), the Borland Resource Compiler tool and other.

Including several binary files in your executable consists of 5 steps:

Create and/or collect all the files you whish to put in an exe,
Create a resource script file (.rc) that describes those resources used by your application,
Compile the resource script file (.rc) file to create a resource file (.res),
Link the compiled resource file into the application’s executable file,
Use individual resource element.

The first step should be simple, simply decide what types of files you would like to store in you executable. For example, we will store two .wav songs, one .ani animations and one .mp3 song.

Before we move on, here are a few important statements concerning limitations when working with resources:

a) Loading and unloading resources is not a time consuming operation. Resources are part of the applications executable file and are loaded at the same time the application runs.

b) All the (free) memory can be used when loading/unloading resources. In other words there are no limits on number of resources loaded at the same time.

c)Of course, resource file do double the size of an executable. If you want smaller executable consider placing resources and parts of your project in DLLs and Packages.

Let's now see how to create a file that describes resources.

Creating a Resource Script File (.RC)

A resource script file is a just a simple text file with the extension .rc that lists resources. The script file is in this format:

ResName1 ResTYPE1 ResFileName1
ResName2 ResTYPE2 ResFileName2
...
ResNameX ResTYPEX ResFileNameX
...

RexName specifies either a unique name or an integer value (ID) that identifies the resource. ResType describes the type of resource and the ResFileName is the full path and file name to the individual resource file.

To create a new resource script file, simply do the following:

Create a new text file in your projects directory.
Rename it to AboutDelphi.rc.

In the AboutDelphi.rc file, have the following lines:

Clock WAVE "c:\mysounds\projects\clock.wav"
MailBeep WAVE "c:\windows\media\newmail.wav"
Cool AVI cool.avi
Intro RCDATA introsong.mp3

The script file simply defines resources. Following the given format the AboutDelphi.rc script lists two .wav files, one .avi animation, and one .mp3 song. All statements in a .rc file associate an identifying name, type and file name for a given resource. There are about a dozen predefined resource types. These include icons, bitmaps, cursors, animations, songs, etc. The RCDATA defines generic data resources. RCDATA let you include a raw data resource for an application. Raw data resources permit the inclusion of binary data directly in the executable file. For example, the RCDATA statement above names the application’s binary resource Intro and specifies the file introsong.mp3, which contains the song for that mp3 file.

Note: make sure you have all the resources you list in your .rc file available. If the files are inside your projects directory you don't have to include full file name. In my .rc file .wav songs are located *somewhere* on the disk and both the animation and mp3 song are located in the project's directory.

Creating a Resource File (.RES)

To use the resources defined in the resource script file, we must compile it to a .res file with the Borland's Resource Compiler. The resource compiler creates a new file based on the contents of the resource script file. This file usually has an .res extension. The Delphi linker will later reformat the .res file into a resource object file and then link it to the executable file of an application.

The Borland's Resource Compiler command line tool is located in the Delphi Bin directory. The name is BRCC32.exe. Simply go to the command prompt and type brcc32 then press Enter. Since the Delphi\Bin directory is in your Path the Brcc32 compiler is invoked and displays the usage help (since it was called with no parapeters).

To compile the AboutDelphi.rc file to a .res file execute this command at the command prompt (in the projects directory):

BRCC32 AboutDelphi.RC

By default, when compiling resources, BRCC32 names the compiled resource (.RES) file with the base name of the .RC file and places it in the same directory as the .RC file.

You can name the resource file anything you want, as long as it has the extension ".RES" and the filename without the extension is not the same as any unit or project filename. This is important, because by default, each Delphi project that compiles into an application has a resource file with the same name as the project file, but with the extension .RES. It's best to save the file to the same directory as your project file.

Create Manifest for Vista UAC if Not Running Under Administrative Rights

2009-04-27T17:05:00.000-07:00

From a developer perspective Windows Vista's UAC can be problematic for some parts of your Delphi application, if the application is not being run by an administartor. One such operation is writing to the Registry database.

Learn how to "request admin rights" by creating an application manifest file....

Windows Vista - User Account Control
User Account Control is a security component in Windows Vista. UAC enables users to perform common tasks as non-administrators, called standard users in Windows Vista, and as administrators without having to switch users, log off, or use Run As.
To help prevent malicious software from silently installing and causing computer-wide infection, Microsoft developed the UAC feature.

From a developer perspective the following UAC features are important:

All processes are started as Standard User as default
A Standard User can not:
Change files in Program Files folders
Change files in Windows or System32 folders
Change registry under HKLM\Software
Change the local machines date and time
...the list continues...
Programmatically Edit Registry to Run Your Delphi Application on Windows Startup
By programmatically editing the Windows Registry, using the TRegistry object, you can you can "automagically" start programs whenever Windows launches.
The procedure you can use to force "auto-run-on-Windows-startup" for your application might look like:

procedure RunOnStartup(const sCmdLine: string; bRunOnce: boolean = false; Remove: Boolean = false) ;
var
sKey: string;
Section: string;
const
ApplicationTitle = ”Your Application TITLE”;
begin
if (bRunOnce) then
sKey := 'Once'
else
sKey := '';

Section := 'Software\Microsoft\Windows\CurrentVersion\Run' + sKey + #0;

with TRegIniFile.Create('') do
try
RootKey := HKEY_LOCAL_MACHINE;
if Remove then
DeleteKey(Section, ApplicationTitle)
else
WriteString(Section, ApplicationTitle, sCmdLine) ;
finally
Free;
end;
end;

On Vista, if the user running the application does not have admin rights the above code would fail, due to UAC!

Faking UAC Rights - How to Request Execution Level

Even if the user running the above code is not an admin, you can, as a developer arm your application with a special kind of embedded resource: application manifest file.

Having the manifest file will ensure Vista's UAC will allow your code to execute.

Here are the steps:

Create XML file with following content:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0]
<assemblyIdentity version="1.1.1.1"
processorArchitecture="X86"
name="YourApplicationExeName"
type="win32"/>
<description>elevate execution level</description>
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2]
<security>
<requestedPrivileges>
<requestedExecutionLevel level="requireAdministrator" uiAccess="false"/>
</requestedPrivileges>
</security>
</trustInfo>
</assembly>
Name this XML file as YourApplicationName.manifest
Create a text file with following content:
1 24 "YourApplicationName.manifest"
Name this text file as YourApplicationName.RC
using the command line execute following command:
brcc32 YourApplicationName.RC -foYourApplicationName.REC
This will create a new resource file called YourApplicationName.REC
Copy this YourApplicationName.REC file in to the resource path of your application.
Include this resource file into the DPR of you application, as like:
{$R YourApplicationName.REC}
Finally build your application - it is now ready to get admin rights on Windows Vista.

Note 1: in the above steps, replace "YourApplicationExeName" with your actual application name.

Note 2: Above steps create a resource file to be stored inside the EXE file of your application. More on .

How to Automate the Above "Create Manifest" Process

To help you automate the process I have written a small program that does all the dirty work for you.

Getting Started with Delphi and C++Builder 2009

2009-04-27T17:02:00.001-07:00

As someone who hires people to document RAD Studio, one of my challenges has been to find training materials for the brand new user. There are excellent sources for experienced users, but the fresh graduate who may have learned C or Java in school did not find a lot of help for learning the latest RAD Studio.

To remedy this, my team put together a new Getting Started guide that describes the UI and a few language basics. Led by Alex Ciobanu, tech writer Lucian Bentea and editor Denisa Ilascu authored the book with the able assistance of Andrei Susnea (on C++Builder) and Alex (on Delphi). Reviewers Kris Houser, Gary Staas, and Tim del Chario gave good feedback. Raluca Dudau was our first "new user test driver" and proved the point that a good training experience sets the basis for future success.

This book will be followed by a series of language guides the team is currently writing, in between their work on new features and perennial updates to the VCL/RTL.

Hint for Delphi Prism

2009-04-26T18:35:00.000-07:00

Why is it all in English? Can I switch the language? Why does the IDE sometimes use multiple languages?

In a recent workshop Olaf Monien and I held together, the question came up if there was a German version for Delphi Prism. Furthermore, people asked us how to switch the language if possible.

Well, Embarcadero provides English, German, French and Japanese translations for Prism. However, the language cannot be selected, because it is determined by the language of the Visual Studio IDE that Prism is being installed into.

Thus, if you have an English version of Visual Studio, Prism will also be in English. Consequently, you will need to install the German version of Visual Studio in order to use the German localization of Prism.

Personally, I am also not very happy with this solution as I would like to be able to switch the languages as well. I solved the issue by using two virtual machines.

Finally, regarding the last issue mentioned in the caption, a lot of messages being shown inside the IDE are taken from resources inside the .NET framework. The framework is independent from Visual Studio and can be in a different language. Thus, if you have not installed the .NET German language package , the error messages for all exceptions thrown by the framework will be in English (or in the language that a language package has been installed for). As Visual Studio uses MS Build to compile or build .NET projects, these messages will always be taken from the framework. This is frequently the first time one notices that the framework is missing a language package when you are running inside a German Visual Studio IDE and the compiler messages are all in English.

To sum it up, one has to be very considerate which products and language packages one installs in order to end up with the development environment in a language one wants to work in.

Generic Methods and Type Inferencing

2009-04-25T20:05:00.000-07:00

In other words - as I understand it - Tiburón/Delphi 2009 will not (initially at least) support type inferencing. To my mind this dramatically reduces the attractiveness of Generic Methods.

What Is Type Inferencing?

As the term suggests, (in this context at least) it is the ability of the compiler to infer the type of some symbol (variable or parameter etc) from the context or code around it.

In C# for example, it means that variables can be declared:

  var a = 10;

The compiler will infer from this that the type of variable a is int (you knew that, right?) without this having to be explicitly declared.

Pop Quiz: What do we think would/should the type of a be if Delphi were to support this?

Hint: What type would a be if it were a constant?

In general I find this to have dubious value, what, for example, can you deduce about the correct usage of a from this:

  var a = someRef.DisplayValue;

To know the type of a you know need to know the type of someRef in order to in turn know the return type of DisplayValue. If browsing a project with all references intact and Code Insight, or equivalent, to deliver this information to you, then all good. But if not, you are going to have a sticky time of it, and either way you still have to trust that the person that wrote the code - which perhaps wasn’t you - also knew those things and didn’t make their own inferencing error.

But what does type inferencing have to do with Generic Methods?

To understand that let’s look at why Generic Methods even come into it.

It all started this evening when I found myself needing to add another overload to my set of Exchange() methods, two of which I show here to give you the idea:

  procedure Exchange(var A, B: Integer); overload;
  procedure Exchange(var A, B: TObject); overload;

(The Exchange procedure exchanges the values of the two passed parameters)

My problem was that because the parameters to these procedures are, by necessity, var parameters, the compiler enforces strict type checking, so the second of the above declarations cannot be used with variables of a TObject derived type, but only variables explicitly and specifically of TObject type itself:

  var
    obj1, obj2: TObject;
    form1, form2: TForm;
  begin
    :
    Exchange(obj1, obj2); // OK - references will be exchanged
    Exchange(form1, form2); // ERROR: No compatible overload
  end;

The second call to Exchange() will not compile because the TForm type parameters are not compatible (from the compiler’s perspective) with the TObject overloaded version of the routine. I have to add another overload with explicitly TForm type parameters.

Not for the first time recently I found myself thinking “If only I had Delphi 2009 - Generic Methods would make this so much easier!”. Then I remembered reading Barry Kelly’s note about lack of type inferencing in Delphi 2009, and an alarm bell started ringing.

The Generic Solution

A generic implementation of an Exchange() procedure should be simple enough, and would go a little something like this:

  procedure Exchange<T>(var A, B: T);
  var
    i: T;
  begin
    i := A;
    A := B;
    B := i;
  end;

Which is nice and neat and cuts down on all those overloads. Unfortunately however, using this procedure is actually now more cumbersome, not less:

  var
    obj1, obj2: TObject;
    form1, form2: TForm;
  begin
    :
    Exchange<TObject>(obj1, obj2);
    Exchange<TForm>(form1, form2);
  end;

Ouch.

Frankly for the time it takes to create a new overload of a trivial routine like this, I would rather take those few seconds and reap the rewards later since - in common with most such routines - the code for the procedure will be written only once but code to call it will be written many, many times.

Voices Off: “But lots of overloads will pollute your namespace!”

You know what? That bothers me a lot less than creating unnecessary work for myself. I’m not the sort of developer that is unable to produce a line of code without invoking Code Completion. I may be unusual in this day and age, but I still write code faster than I can pick it from drop-down lists.

And this in Win32 Delphi at least is surely the biggest impact? As far as the code goes, any unused overloads will be pruned out by the linker. In .NET - aiui - a cluttered namespace becomes a public nuisance, so the imperatives are somewhat different perhaps.

How Would Type Inferencing Help?

Well, assuming that any future Delphi type inferencing system could determine the appropriate type from the parameters (as it can in C#) then we could invoke our generic Exchange<T>() method by simply writing:

  var
    obj1, obj2: TObject;
    form1, form2: TForm;
  begin
    :
    Exchange(obj1, obj2);
    Exchange(form1, form2);
  end;

i.e. just as we can do with overloads.

But until this is possible at this stage I was feeling that I would continue with overloads until - at least - type inferencing were available. They are just as type-safe and ironically produce “consumer” code that should be entirely compatible with a future generic methods implementation that is bolstered by type inferencing.

Using generic methods without type inferencing (in these sorts of cases at least) will simply create unnecessarily verbose and cumbersome “consumer” code.

But not being one to give in, I considered some alternative approaches.

A Truly generic Approach?

Alternatively, Delphi already provides a means to implement a truly generic (lower case “g’) Exchange() method - untyped parameters:

  procedure Exchange(var A, B);
  var
    i: ?
  begin
    i := A;
    A := B;
    B := i;
  end;

You will immediately notice of course that this implementation is neither valid nor complete. The type of i (for “intermediate”, if you were wondering) is not known and indeed not knowable. And furthermore, the compiler simply won’t accept that A := B assignment since it doesn’t know the types of A and B it cannot know what instructions are needed. For the same reason, the XOR trick won’t work either. Those untyped parameters seem to have lead us to a dead end.

Not quite. (If you are squeamish and/or don’t like smelly code you might want to avert your gaze about now, or at least pinch your nose):

  procedure Exchange(var A, B);
  var
    aa: Integer absolute A;
    bb: Integer absolute B;
    i: Integer;
  begin
    i  := aa;
    aa := bb;
    bb := i;
  end;

The absolute keyword is not something to be used lightly - it tells the compiler that the variables aa and bb exist at the same location as the parameters A and B - in this case the compiler even takes care of the fact that the parameters are passed by reference.

Since the variables are typed and the parameters are untyped, how can this be safe?

Well, frankly it isn’t.

In practice if the type of A and B is not the same size as an Integer (32-bits) then things are not going to go at all according to plan.

Equally of course though, if you only ever call this implementation routine with 32-bit sized parameters (which includes strings, object references etc) there won’t be a problem. “IF”.

I should point out at this stage that I explored this approach as a curiosity. I am certainly NOT recommending it! For one thing it is not “truly generic” at all - it only appears to be but in fact has fairly strict conditions for correct use, and does not benefit from any assistance from the compiler to ensure that you do in fact use it correctly!

But we have one more trick up our sleeve - there is (at least) one more way to skin this particular cat that is safer than an untyped parameter approach and only a little more cumbersome to use than a non-type-inferenced Generic approach.

X-Rated Code - Being Explicit

A var parameter is syntactic sugar for passing by referencing and allowing modification of the de-referenced value. We can of course achieve the same thing by taking care of the de-referencing aspects ourselves and explicitly passing references to values, rather than the values themselves:

  type
    PObject = ^TObject;

   :

  procedure Exchange(const A, B: PObject);
  var
    i: TObject
  begin
    i  := A^;
    A^ := B^;
    B^ := i;
  end;

And to call this:

  var
    obj1, obj2: TObject;
    form1, form2: TForm;
  begin
    :
    Exchange(@obj1, @obj2);
    Exchange(@form1, @form2);
  end;

All of which sits happily alongside any other overloaded versions of Exchange(), but which unfortunately requires consumer code that will not be compatible with a future Generic Method implementation of the routine.

BUT, even this won’t work if we are compiling with Typed @ Operator option enabled.

So I’m left a little stumped.

There are many ways to go about this. If it weren’t for the fact that Generic Methods are nearly upon us I would favour the explicit de-referencing approach. But the desire to create code today that will be compatible with impending new language features is quite compelling. Then again, until we also get type inferencing, a Generic Methods based approach isn’t going to be compatible with anything we can write today anyway.

Despite myself, the untyped parameter approach could yet prove too tempting to resist (particularly if I find myself needing yet another class-specific version of Exchange()) since all the types that I’ve ever found myself wanting to Exchange() meet the 32-bit criteria.

It really hinges on when we might see type inferencing in a Delphi compiler. If that is something we are likely only to see in Commodore then worrying about compatability of a few calls to Exchange() could prove somewhat misplaced given the far wider issues likely to arise from the move to a 64-bit compiler.

A Compromise?

In the meantime I wonder whether it would not be possible to have a compiler option to disable such strict type checking on var parameters, ideally on a method-by-method basis.

After all, we still have such an option for short string var parameters (although having never had cause to use it I don’t know if it works in quite the way I have in mind - i.e. on declarations of rather than calls to, methods).

In the case of class-type var parameters the more relaxed type checking could allow parameters of any type correctly derived from the formal type:

  interface
    {$VARSTRICTCLASSTYPE OFF}
    procedure Exchange(var A, B: TObject);
    {$VARSTRICTCLASSTYPE ON}

  implementation

    procedure Exchange(var A, B: TObject);
      :
    end;

Then again, I can’t think of any other concrete examples where such a capability would have any practical use. But if this were possible to implement more quickly and safely than a comprehensive type inferencing system, I think I’d take it to keep me going.

Proposal for Automated Variables

2009-04-25T20:01:00.000-07:00

Yesterday I logged a Quality Central report proposing the addition of support for “automatic variables” to the Delphi language. Not only is it an excellent idea (in my humble and utterly objective opinion :)), but there is already a keyword in the language that could be co-opted for this purpose, a keyword that has been at something of a loose-end since it was deprecated (rendered obsolete even) a long, long time ago…

The language keyword in question is automated. This was introduced in Delphi 2.0 as part of the initial implementation to support COM automation and, if memory serves, deprecated in the very next release when “proper” (albeit COM) interfaces were added to the language.

The functionality that AutoFree() provides is similar to the concept of an auto pointer - a specific variant of the general concept of a smart pointer. “auto”… “automatic”… “automated”… the similarity in the terms, and the relevance of the semantics, is striking. To me at least.

The proposal in Quality Central drew inspiration directly from exchanges in the comments on my post on an AutoFree() implementation and a realisation that the required behaviour is very similar to that already implemented for interface references - it would not be entirely alien to the Delphi language.

Indeed I believe it would be quite easily understood and welcomed by most, if not all, developers.

The Proposal

The automated keyword should be supported as a decoration on variable declarations. That is local variables, member variables and unit variables:

interface

  type
    TFoo = class
    private
      fBar: TBar automated;
    end;

implementation

  var
    _Bar: TBar automated;

  function FooFn;
  var
    bar: TBar automated;
  begin
    :
  end;

The rules for the keyword and the effect of it shall be as follows:

- The automated keyword shall be valid only for pointer and object reference type variables. (*)

- When marked as automated the compiler shall emit code to initialize a variable to NIL. This already occurs for local variables of certain types, most notably interface references, as well as all member variables (albeit indirectly in that case), and currently has to be specified directly, if required, for unit variables.

- When marked as automated the compiler shall emit code to finalize a variable in a manner appropriate to it’s type. For object references this shall be a call to Free; for pointers a call to FreeMem(). This is directly equivalent to the code already emitted by the compiler to finalize interface references by calling Release().

- automated would not be combinable with absolute.

(*) - it could also be supported on record types with the proviso that the record type in question supports a parameterless constructor (to be called to initialize the record) and a lone destructor (called to finalize the record). But to keep things simple lets stick to object references and pointers, for now at least.

The effect on code of the use of this keyword would be to facilitate:

1. resource protection for temporary objects held in local variables without the need for try..finally blocks.

2. reliable clean up of dependent objects in object hierarchies without the need for objects to implement a destructor (solely) to free those dependent objects. Destructors may still be necessary for other purposes of course.

3. reliable clean up of unit (a.k.a “global”) objects without the need for a unit finalization. Again, finalization may still be required for other purposes.

Note however that it would not prevent these existing techniques from functioning, if required or preferred.

There is only one possible danger that I foresee, which is that a developer might mark a variable as automated but then dispose of the referenced object/memory explicitly without re-initializing the variable. e.g.:

  procedure SomeFn;
  var
    bar: TBar automated;
  begin
    bar := TBar.Create;
    bar.Free;
  end;

In this case, when SomeFn exits, the finalization of bar will likely result in an error since bar has been left holding a reference to an object that has already been Free‘d.

Note that the initialization of bar as NIL (as a consequence of being automated) specifically avoids any problem if bar is only assigned a reference conditionally in the code.

Note also that explicitly disposing an automated variable is not in and of itself problematic, as long as the variable is also then explicitly re-set to NIL. In the above example, if bar had been NIL‘d once freed, or FreeAndNIL() had been used, then there would not be any problem with the automated behaviour of bar.

The code below illustrates safe explicit disposal and potentially conditional assignment of an automated reference:

  procedure SomeFn;
  var
    bar: TBar automated;
  begin
    bar := TBar.Create;

    // do some work with "bar"

    FreeAndNIL(bar);

    if SomeCondition then
    begin
      bar := TBar.Create;
      // do more work with a new "bar"
    end;
  end;

This code is perfectly safe, will not result in a runtime error and will not leak a TBar.

The potential dangers and pitfalls of an automated variable behaviour implemented as described are actually no different to the potential dangers and pitfalls associated with the manual techniques that it could replace.

I should also mention that I cannot see that the proposal described here would necessarily interfere with, or be interfered with by, the existing, deprecated usage of the automated keyword.

A final observation is that this implementation “feels very Pascal’ly” to me. In a good way.

Raising The Dead

2009-04-25T19:58:00.000-07:00

What can possibly go wrong in the simple act of modifying the message of an exception to add some additional diagnostic information and then re-raising it?

Quite a lot actually, and all from one simple mistake.

Here’s a simplified version of a fairly common construct that you will encounter in Delphi code:

  var
    a: Integer;
  begin
    try
      a := 0;
      Caption := IntToStr(100 div a);
    except
      on e: Exception do
      begin
        e.Message := 'Oops: ' + e.Message;
        raise e;
      end;
    end;
  end;

The intention is to add some additional diagnostic information to an exception message to assist in debugging (assuming it is not subsequently handled by some exception handler further up the stack), but without handling the exception itself. i.e. to re-raise the exception.

Fairly innocuous and entirely straightforward - most experienced Delphi developers can probably do this in their sleep.

Which is I think what happened here - sleep-coding I mean - because if you compile and run this code your exception handling will cause an apparent meltdown in your application. After the initial exception is reported - seemingly normally - you will then encounter access violations and even external exceptions.

Some of you may have spotted the problem already, but it took me 20 minutes of trying to figure out why such seemingly simple and harmless code was causing access violations and external exceptions etc etc.

How can raising an exception do that? Perhaps the method was being invoked on an invalid instance or some other similar bad pointer was getting involved in the situation somehow (which was far more complex than this simplified version).

The problem of course lay in the mostly harmless looking:

      raise e;

To re-raise an exception you do not specify an exception instance. You only do that when raising a brand new exception. By referencing the “caught” exception instance “e” in the raise statement, the runtime will naively handle that exception (destroying the exception instance) and then goes right ahead and raises that destroyed - dead - instance.

The exception instance gets handled AND re-raised and when the already handled (destroyed) exception arrives at another exception handler, all hell breaks loose.

It strikes me that the compiler/RTL between them should be able to tell when you do this and treat “raise e” as simply “raise” when “e” is a reference to the currently-being handled exception.

But for now, it’s something to be wary of.

Footnote

There’s an entirely clean triple-entendre in this post’s title.

1. The technical aspect covered above - raising a handled (dead) exception

2. Stress related health concerns that have been bothering me for the past 12 months or so and which came to a head at the end of last year, are hopefully if not behind me then at least waving as I sail them by on the freeway. I did not actually die - quite obviously - but believed I was close to it on more than one occasion. and which caused me to take a break from engaging in the Delphi community including this blog. My activity may not be as high as it once was, at least for a while, but I am re-raised at last.

3. It is no exaggeration to say that a factor, albeit a small one, in my recovery has been the undoubted resurgence in the vitality of Delph itself. A raising from the dead (again? some might say) of Delphi.

Delphi Prism and DataSnap Server Method Stream Parameters

2009-04-25T19:46:00.000-07:00

Stream Parameter Types

This table shows the parameter types and return types in the stream samples. The columns under “Server Parameter” describe the parameter or return type in the Delphi DataSnap servers methods. The “Delphi Type” column shows the corresponding type used in the Delphi client. The “Delphi Prism Type” column shows type used in the Delphi Prism client.

Code Samples

The following code samples show the differences between calling server methods with DbExpress in Delphi compared to ADO.NET in Delphi Prism.

key-feature of NativeDB

2009-04-25T19:45:00.000-07:00

Direct database access is the single most important
key-feature of NativeDB. NativeDB skips both the Borland Database Engine (BDE),
the Microsoft's Open Database Connectivity (ODBC) and OLEDB layers. Thus make it
easy to deploy, install and configure your end-user application. Instead it connects
directly to the database layer provided by the database manufacturer. The result is
high performance data-access, with less code overhead compared to any other standard
database interface available today. NativeDB is a set of components that can work
or link directly with your application executable. You don't have to worry about
BDE, ODBC, MDAC or OLEDB distribution, configuration and version conflict issues
anymore.

How can XLSReadWriteII help you

2009-04-25T19:42:00.000-07:00

Native access to Excel files. The user
doesn't need to have Excel, or any other software installed.

XLSReadWriteII works as an invisible Excel
workbook. All cell values are always accessible.

Stability. One of the major goals with
XLSReadWriteII was to create a product that won't corrupt the Excel files
and won't alter any data in the file.

XLSReadWriteII is easy to use. With the

formatting interface, you can format cells through a
cell object.

Fast and efficient support when you have
any questions.

No runtime fees for the component.

Full source code included.

We released the first version of
XLSReadWrite in 1998. At that time it was the only component that could
read and write Excel 97+ files. We are commited to have the leading Excel
solution for Delphi in the future as well.

How to Hook the Mouse to Catch Events Outside of Delphi application

2009-04-24T19:08:00.000-07:00

Learn how to track the mouse activity even when your application is not active, sits in the Tray or does not have any UI at all.

By installing a system wide (or global) mouse hook you can monitor what the user is doing with the mouse and act accordingly.

Windows Hooks?

In short, a hook is a (callback) function you can create as part of a DLL (dynamic link library) or your application to monitor the 'goings on' inside the Windows operating system.
There are 2 types of hooks - global and local. A local hook monitors things happening only for a specific program (or thread). A global hook monitors the entire system (all threads).

The article "An introduction to hook procedures", states that to create a global hook you need 2 projects, 1 to make the executable file and 1 to make a DLL containing the hook procedure.
Working with keyboard hooks from Delphi explains how to intercept the keyboard input for controls that cannot receive the input focus (like TImage).

Let's Hook the Mouse ...

By design, the movement of the mouse is restricted by the size of your desktop screen (including the Windows Task Bar). When you move the mouse to the left/right/top/bottom edge, the mouse will "stop" - as expected (if you do not have more that one monitor).

Here's an idea for the system-wide mouse hook ....

If, for example, you want to move the mouse to the right side of the screen when it moves toward the left edge (and "touches" it), you might write a global mouse hook to reposition the mouse pointer.

You start by creating a dynamic link library project. The DLL should export two methods : "HookMouse" and "UnHookMouse".

The HookMouse procedure calls the SetWindowsHookEx API passing the "WH_MOUSE" for the first parameter - thus installing a hook procedure that monitors mouse messages. One of the parameters to the SetWindowsHookEx is your callback function Windows will call when there is a mouse message to be processed:

SetWindowsHookEx(WH_MOUSE, @HookProc, HInstance,0) ;

The last parameter (value = 0) in the SetWindowsHookEx defines we are registering a global hook.

The HookProc parses the mouse related messages and sends a custom message ("MouseHookMessage") to our test project:

function HookProc(nCode: Integer; MsgID: WParam; Data: LParam): LResult; stdcall;
var
mousePoint: TPoint;
notifyTestForm : boolean;
MouseDirection : TMouseDirection;
begin
mousePoint := PMouseHookStruct(Data)^.pt;

notifyTestForm := false;

if (mousePoint.X = 0) then
begin
Windows.SetCursorPos(-2 + Screen.Width, mousePoint.y) ;
notifyTestForm := true;
MouseDirection := mdRight;
end;

....

if notifyTestForm then
begin
PostMessage(FindWindow('TMainHookTestForm', nil), MouseHookMessage, MsgID, Integer(MouseDirection)) ;
end;

Result := CallNextHookEx(Hook,nCode,MsgID,Data) ;
end;

Note 1: Read the Win32 SDK Help files to find out about the PMouseHookStruct record and the signature of the HookProc function.

Note 2: a hook function does not need to send anything anywhere - the PostMessage call is used only to indicate that the DLL can comunicate with the "outer" world.

Mouse Hook "Listener"

The "MouseHookMessage" message is posted to our test project - a form named "TMainHookTestForm". We override the WndProc method to get the message and act as needed:

procedure TMainHookTestForm.WndProc(var Message: TMessage) ;
begin
inherited WndProc(Message) ;

if Message.Msg = HookCommon.MouseHookMessage then
begin
//implementation found in the accompanying code
Signal(TMouseDirection(Message.LParam)) ;
end;
end;

Of course, when the form is created (OnCreate) we call the HookMouse procedure from the DLL, when it gets closed (OnDestroy) we call the UnHookMouse procedure.

Download both projects to test and further explore the code.

Note: hooks tend to slow down the system because they increase the amount of processing the system must perform for each message. You should install a hook only when necessary, and remove it as soon as possible.

Castalia for Delphi

2009-04-24T18:55:00.000-07:00

Great developers need great tools
Castalia transforms the Delphi programming environment into an amazing development platform. Castalia lives on the bleeding edge of IDE technology, giving you cutting edge tools to write better code faster, understand code more accurately, and improve code you've already written.

How to Unit Test a Data Module

2009-04-23T19:20:00.000-07:00

Data modules are unit tested in exactly the same way that you would unit test any other piece of code. That is, by refactoring the code to be tested in such a way as to separate it from code not relevant to the test. But since people occasionally seem to find this confusing, perhaps a practical example is in order.

Imagine that you have been given the task of fixing a bug in the following code. Before you fix the bug, you would like to write a unit test which shows the bug, in order to prevent regressions after you fix it.

procedure TMyDM.qryFooCalcFields(DataSet: TDataSet);
var
  Minimum, PieceRate: Double;
begin
  Minimum := qryFooHOURS.Value / qryFooMINIMUM_WAGE.Value; // oops; should be *
  PieceRate := qryFooPIECE_RATE.Value * qryFooPIECES.Value;
  qryFooEarnings.Value := Max(Minimum, PieceRate);
end;

Now, tests which access a database are, generally speaking, integration tests rather than unit tests. But the code you’ve been asked to fix seems to be pretty wound up in database access. It doesn’t have to be, though. Let’s refactor:

function TMyDM.CalcEarnings(AHours, AMinimumWage, APieceRate, APieces: Double): double;
var
  Minimum, PieceRate: Double;
begin
  Minimum := AHours / AMinimumWage; // oops; should be *
  PieceRate := APieceRate * APieces;
  Result := Max(Minimum, PieceRate);
end;

procedure TMyDM.qryFooCalcFields(DataSet: TDataSet);
begin
  qryFooEarnings.Value := CalcEarnings(qryFooHOURS.Value,
    qryFooMINIMUM_WAGE.Value, qryFooPIECE_RATE.Value, qryFooPIECES.Value);
end;

Resist any temptation to actually fix the bug at the moment; we went to write a unit test which fails before making it pass by fixing the bug. Note that you can make CalcEarnings static, meaning you won’t even need an instance of the data module in order to unit test the function:

procedure TestMyDM.CalcEarnings;
var
  Actual, Delta, Expected, Hours, Minimum, PieceRate, Pieces: Double;
begin
  Hours := 1;
  Minimum := 7;
  PieceRate := 1;
  Pieces := 1;
  Expected := 7;

  Actual := TMyDM.CalcEarnings(Hours, MinimumWage, PieceRate, Pieces);

  Delta := 0.0001;
  CheckEquals(Expected, Actual, Delta);
end;

There are aspects of this code which will be hard to unit test. I could, for example, pass the wrong field value into the refactored function. I can fix that by abstracting the data access layer, but it’s not a complete fix, since I might have the wrong data in the database. The fact is that unit testing can only catch so much, and integration testing will always be necessary, as well. The important point is that I have isolated the bug which I was asked to fix, and future regressions in that code will now be caught.

I wonder if some Delphi users are confused by the term "unit test." The word "unit" means something very different in Delphi than it does in the term "unit test." In "unit testing," the word "unit" refers to a single piece of functionality. In Delphi, a unit (reserved word) is a source code file. When you write unit tests, you do not have to test an entire unit at a time. Unit tests are for specific cases of using a specific function.

New Delphi Product Manager and R&D Manager

2009-04-23T19:16:00.000-07:00

You probably have already heard, but people inside CodeGear have shifted their roles, including the Delphi Product Manager.

Nick Hodges, who was Delphi Product Manager is now Delphi R&D Manager. So rather than promoting the product to the community he's more in charge of shaping the future of the product. Having known Nick for many years, I think this is going to be interesting. You can read more on his blog post A New Role for Nick. Let me thank him for his work at Product Manager, that started in a period of turmoil but ended with the product back in a good shape, and wish him best luck for this new assignment. And if you need ideas about Delphi future, I'm ready to provide a few...

Mike Rozlog, who was JBuilder Product Manager, is now Delphi Product Manager (see his Changes in the Wind Part II). It won't be easy to get out of Nick's shadow, but Mike has a long-term relationship with Delphi as a product, and even if he's not such a prominent figure in the community right now, he can certainly gain that status and help the product go forward. He looks to have more of a "database/business" oriented perspective, and this can be very important to push Delphi it one of its fundamental roles (that of a client/server tool for business applications) that at times has been a bit neglected.

Chris Pattinson, who was heading the Quality Assurance team for RAD Studio (after some big troubles with quality in previous versions), has been appointed as Director of Quality Assurance for Embarcadero as a whole, supervising the development of both CodeGear and DatabaseGear products. Kudos to Chris for this key assignment, I'm sure he'll do well as he helped Delphi become a solid tool once more.

Well, let me thank the three of them for what they have done in the past at CodeGear and wish them all the best in their future CodeGear/Embarcadero roles. I hope to have time to chat to at least Nick and Mike at Delphi Live.

How to Right Align a Menu Item

2009-04-23T19:10:00.000-07:00

In most applications all (top level) menu items are aligned at the =
left side=20
of the menu bar. I'm sure you have seen applications with at least one =
item=20
aligned on the right side. In most cases this was the "Help" menu item.=20

Here's how to align a form's Help menu item (for example) on the =
right side=20
of the menu bar, in Delphi applications.=20

Add a TMainMenu component to a form (Form1)=20
Add several (top level) menu items (with sub items)=20
Have a menu item named "HelpMenuItem"=20
Use the code below in the form's OnCreate event.=20
Run the project ... note that the "Help" item is aligned on the =
right side=20
of the menu bar.

procedure TForm1.FormCreate(Sender: =
TObject)=20
;
var
mii: TMenuItemInfo;
=
MainMenu:=20
hMenu;
Buffer: array[0..79] of=20
Char;
begin
MainMenu :=3D=20
Self.Menu.Handle;

//GET Help Menu Item=20
Info
mii.cbSize :=3D SizeOf(mii) ;
=
mii.fMask=20
:=3D MIIM_TYPE;
mii.dwTypeData :=3D =
Buffer;
=20
mii.cch :=3D SizeOf(Buffer) ;
=
GetMenuItemInfo(MainMenu,=20
HelpMenuItem.Command, false, mii) ;

//SET Help =
Menu=20
Item Info
mii.fType :=3D mii.fType or=20
MFT_RIGHTJUSTIFY;
SetMenuItemInfo(MainMenu,=20
HelpMenuItem.Command, false, mii) ;
end;

Optimal project settings

2009-04-23T02:28:00.001-07:00

What will we talk about?
Ok, let’s see, what options do I mean: open your project’s options and take a look at “Compiling” and “Linking” pages (those pages are called “Compiler” and “Linker” in old Delphi versions):

“Compiling” page in project’s options (D2009)

“Linking” page in project’s options (D2009)

On “Compiler” page we are interested in “Stack Frames”, group of “Debug information”, “Local Symbols” and “Symbol reference info”, “I/O Checking”, “Overflow checking” and “Range checking”. On “Linking” page - “Map file”, “Debug Information” (this option is known as “Include TD32 debug info” in previous Delphi versions) and “Include remote debug symbols”.

Let’s see what these options do. And then - what are the best settings for them and why. We will have in mind the scenario of usual application and EurekaLog-enabled application.

Besides, the project settings can differs for debug and release targets - i.e.: do you compile application for your self (for debugging) or for end-user deployment. There are settings profiles (Debug and Release) in new Delphi versions. You can specify individual settings for each profile and just toggle between them before compilation. Older Delphi version have only one global profile, so you have to change every single option manually.

Please, remember, that you need to make a full build (and not just compile), if you’ve changed one of those options.

What do these options mean?

The most important settings are set of options “Debug information” (”Compiling” page), “Local Symbols” and “Symbol reference info”.

The program is set of machine’s (CPU) instructions - which are just numbers. The source code is a text file. The question: how does the debugger know, when he needs to stop, when you are setting a breakpoint in your source? Where is correspondence between raw numbers and human-readable text?

This correspondence is a debug information. Roughly speaking, the debug information is set of instructions like: “the machine codes no. 1056-1059 correspond to line 234 of Unit1″. The debugger works thanks to such debug info.

And these options? They controls the generation of debug information for your units.

The debug information is stored in dcu-files together with its compiled code. I.e. the very same Unit1.pas can be compiled into different dcu-files (with or without debug information). The debug information increases compilation time, size of dcu-files, but it does not affect size or speed of resulting application (i.e. debug information is not included into application).

There are cases, when you want to have debug information in your files or (at least) near them. For example: if you are going to do remote debugging or debugging of external process. OR if you want to have human-readable call-stack in your exception diagnostic tool (EurekaLog).

You can embed debug information into your files by two ways: either you play with project’s options (using “Map File”, “Debug information” (Linker)/”Include TD32 Debug info” or “Include remote debug symbols” options) OR you use some sort of expert (for example, EurekaLog or JCL), which injects debug information in his own format into your executables.

“Debug information” – that is the debug info itself. You should enable this option if you want to do step-by-step debugging or have call stacks with names. EurekaLog enables this option automatically for you. But if you mess with your project’s settings…

“Local symbols” – it is “addon” for usual debug information. This is correspondence between program’s data and variables names in source code. You need to enable this option if you want to see and change variables. Also, call stack window in Delphi can display function’s arguments with this option.

“Reference info” – this is additional information for code editor, which allows him to display detailed information about identificators. For example: where were a variable declared.

Those options are very cose related and usually there is no need to enable or disable only one of them - they are switched together.

“Use Debug DCUs” - this very important option switches compilation between using debug and release versions of standard Delphi’s units. If you were attentive, then you could notice that real pas-files in Source folder are never used during compilation. Instead, the precompiled files (in dcu) are used. They are taken from Lib or Lib\Debug folders. This trick greatly decreases compilation time. Because dcu can be compiled with and without debug information - there are two sets of dcus in Lib folder. By toggling this option you’ll specify which one Delphi should use for you. If you switch this option off - then you won’t be able to debug standard Delphi code or see detailed call stack for it.

“Stack Frames” - this option controls stack frames generation. If the option is off then stack frames won’t be generated unless they are needed. If the option is on - then stack frames will be generated always. Stack frames are used for frame-based stack-tracing method (the raw-tracing method do not require stack frames). I.e. it is used for building call stack. In usual application stack frames are generated almost everywhere.

“Range checking” - this is a very useful helper for debugging problems with array-based structures. With it, compiler will insert additional checks (for strings, arrays, etc), which checks the correctness of indexes. If you (by mistake) pass an invalid index - the exception of type ERangeError will be generated. And you can find your error. If the option is off then there is no additional code. Enabling this option slightly increases size of your application and slows down it execution. It is recommended to turn this option for debugging only.

“Overflow checking” - it is somehow similar to “Range checking”, except checking code checks overflows in arithmetic operations. If result of operation is not suitable for storage variable - then exception EIntOverflow will be raised. For example: we have a byte variable, which holds 255 now. And we add 2 to it. There should be 257, but it can not be stored in byte variable, so real result will be 1. That is integer overflow. This option is actually rarely used. There are three reasons for it: different code often depends on it to be turned off. That means that enabling this option will break such code. Secondly: usually you work with Integer, and your logic rarely involves dealing with values on Integer’s range border. And third: arithmetic operations is very common code, so adding additional checks to every operation can slow down your code significantly.

“I/O Checking” - this option is used for working with “files in Pascal-style” (AssignFile, Reset, etc), This feature is deprecated and you shouldn’t use these routines and therefore you don’t need to touch this option.

“Map file” - by enabling this option you tell the Delphi’s linker to create a separate map-file along with your executable. Map file contains human-readable representation of debug information. Different settings for this option controls the detalization level of output. Usually, there is no need to change it to anything, which differs from “Off” or “Detailed”. The map-file is used by various tools as primary source of debug information. For example, EurekaLog automatically turns this option on and uses map-file to create a debug information in its own format and then injects it into application. That is why you rarely need to change this option manually.

“Debug Information” (Linker)/”Include TD32 debug info” - this option embeds debug information for external debugger in TD32 format into your application. You may need this option if you use “Run”/”Attach to process” and Delphi can not find debug information. Note, that size of your application can increase 5-10 times by enabling this option. So, it is not good choice for storing debug info in release version - it is better to use EurekaLog (or any other source of debug information, which is supported by EL; for example - JCL).

“Include remote debug symbols” - very similar to previous option, but this creates a rsm-file with debug information for Delphi remote debugger. You need this option, if you want to do remote debugging.

Note, that these options can be enabled not only globally, but also separately for each unit (several options can affect single routines or, even, lines of code). This is done by using usual compiler directives (you can see them in help - by pressing F1 while you stay in project’s options dialog). For example, “Stack Frames” is controlled by {$W+} and {$W-}.

So, by summarizing all this info, we can give a recommendations for different cases. They are written down below. Settings, which differs from defaults are marked in bold (i.e. you should toggle them manually).

Usual application, without EurekaLog

Base settings for each profile

All debug options (”Debug information” (Compiler), “Local symbols”, “Reference info”) does not affect the resulting application and do not disturb us - so you usually should keep them always on.

“Use Debug DCUs” - set it as you like (depending on: “do you want to debug standard Delphi code or not?”).

There is no need to turn on “Stack Frames” option.

There is no need for map-files.

Debug profile

Turn on “Range checking” and (optionally) “Overflow checking”.

“Include TD32 debug info” - enable it only if you use “Attach to process” while debugging.

“Include remote debug info” - enable it only if you want to use remote debugger.

Release profile

Turn off “Range checking”, “Overflow checking”, “Include TD32 debug info” and “Include remote debug info”.

EurekaLog-enabled application

Base settings for each profile

All debug options (”Debug information” (Compiler), “Local symbols”, “Reference info”) should be definitely turned on. Otherwise, call stack functionality won’t be working.

There is no need to turn OFF “Stack Frames” option.

Generation of map-file should be turned on, but EurekaLog’s expert takes cares of it.

Debug profile

“Use Debug DCUs” - set it as you like.

Turn on “Range checking” and (optionally) “Overflow checking”.

“Include TD32 debug info” - enable it only if you use “Attach to process” while debugging.

“Include remote debug info” - enable it only if you want to use remote debugger.

Release profile

Turn on “Use Debug DCUs” option.

Turn off “Range checking”, “Overflow checking”, “Include TD32 debug info” and “Include remote debug info”.

What can go wrong if I mess up with my settings?

Well, that means, for example, impossibility of debugging (say, missed information for remote debugger of turned off “Debug information” (Compiler) option), large size of application (for example - you forgot to turn off “Debug information” (Linker)/”Include TD32 debug info”), slow execution (for example: application was compiled with debug code), missed or partial call stacks in EurekaLog (for example, you managed to turn off “Debug information” (Compiler) or you do not use “Use Debug DCUs”). In rare cases there can be work/not-work difference (for example, swithing on “Stack frames” can slightly decrease maximum depth of recursive algorithm). There are few other minor issues.

BTW, if you develop a component - do not forget that Delphi have two sets of dcus. Generally, toggling debug options does not affect interface and implementation parts of dcus. So, different versions of dcus are compatitible with each other. But it is not always so - code may use conditional defines. That is why it is possible to have binary incompatible versions of dcu-files of the same source code (and here is a real-life example with D2009 and InstanceSize method).

For this reason, you should also create a two sets of dcu-files: first one should be compiled against usual dcu (”Use Debug DCUs” turned off) and the other one - with debug dcu-files (”Use Debug DCUs” turned on). BTW, it is not important, how you’ll set “Debug information” (Compiler) option for your component (of course, it is only from POV of binary compatibility).

Profiler for Delphi

2009-04-21T18:37:00.000-07:00

is a tool to measure the runtime of programs written in Delphi Object Pascal. If an application is too slow, ProDelphi gives the necessary information to optimize it.

The principle of source code instrumenting , a sophisticated correction algorithm and the unique granularity of 1 CPU cycle guarantee to get correct measurement results . Source code instrumenting guarantees that always every part of an application is measured.

This is contrary to sampling profilers which give random measurement results , the exact execution time of a procedure can not be determined (see also profiler types ). To compare the measurement accuracy of ProDelphi with any other profiler, a profiler tester is supplied in the download area.

Because of the outstanding low measurement overhead even time critical applications can be measured.
I ntegration into the Delphi IDE, a call graph and a handy viewer guarantee a fast optimization process.

Writing a RemObjects SDK for .NET Server and Mac Client

2009-04-21T18:31:00.000-07:00

In this article, we will walk through the process of creating a fully working client and server application using RemObjects SDK, with the server written in .NET and the client written for Mac OS X.

The article assumes you have Visual Studio and the latest RemObjects SDK for .NET installed in a Windows VM or on a separate PC on your network, and the Xcode 3.0 with the latest RemObjects SDK for OS X on your Mac.

The .NET Server

Start off by going into Visual Studio to create your server application. Choose FileNew Project from the menu and locate the RemObjects SDK node underneath the language of your choice (C#, Delphi Prism or Visual Basic .NET) - for our example, we’ll choose C#, as most people are familiar with that. Don’t worry, you'll be writing literally two lines of code for this, which easily translate into Delphi Prism or VB if necessary).

For the purposes of this article, choose the Windows Forms Server option, pick a destination folder and name your project “MyROServer”. Click OK to continue.

Next, you will be presented with the New RemObjects SDK Server wizard. Since we will be creating our client application in Xcode, on the Mac side, you can uncheck the Also create a matching client application checkbox. Beyond that, all the default settings should be good, although in a real-life project you may want to click into Advanced Project Options to configure names for service and library, or choose different communication channels. Once again, click OK to have the project created.

On the right-hand side of Visual Studio, you now see your project in Solution Explorer. Next to the usual source files in your language of choice (here .cs), you will see a .RODL file which contains the service definitions for your server. Double-click the file (or press the red RemObjects SDK icon in the toolbar above) to edit the RODL.