Borland Delphi

Read mouse pointer aka cursor position in Delphi!

2011-07-21T11:51:00.000-07:00

Well this seems to a problem sometimes when someone asks us how to find where my cursor is currently located. Well why to say when we can infact show where actually is our mouse cursor at given point in time. To do this we will create a simple Delphi program as follows -

program Project1;
{$APPTYPE CONSOLE}
uses
SysUtils, Controls, Windows;

var
MyMouse : TMouse;
begin
MyMouse := TMouse.Create;
While True do
begin
WriteLn('(X, y) = (' + inttostr(TPoint(MyMouse.CursorPos).x) + ',' + inttostr(TPoint(MyMouse.CursorPos).y) + ')');
sleep(300);
end
end.

As we can see we create a simple Mouse cursor for ourselves in this small program and simply place it in a while loop of 300 ms to trace the current position of mouse cursor in our screen.

Simple isn't it?

Limit of Recursion!

2011-07-21T11:38:00.000-07:00

Recently I was going through Linked in Delphi user's group and found that few programming sections in a programming site needs examples in Delphi to demonstrate the methodology of implementing solution to a problem in various languages. On visiting the site I found that there is a need of particular example to find - Limit of Recursion as implemented in the language. This is a very interesting question as we all use recursion for implementing various solutions but we rarely care to find the actual limit to which we can implement recursion. Although most of this problems answer depends on the memory available to particular systems however we still can check this limit by implementing a very basic recursive function.

The idea behind this simple program is to keep on iterating and visit nest level for a recursive function till the time we go out of memory. So the limiting condition here is the draining of the memory. A simple program like the following will demonstrate this limit -

unit Unit1;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls;

type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
Level : integer;
end;

var
Form1: TForm1;

implementation

{$R *.DFM}

function Recursive(Level : integer) : integer;
begin
try
Level := Level + 1;
Recursive(Level);
except on e: Exception do
Result := Level;
end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
ShowMessage('Level = ' + inttostr(Level));
ShowMessage('Level = ' + inttostr(Recursive(Level)));
end;

end.

This program takes up an integer value and tries to increment the value and call the function till StackOverflow error occurs and then simply prints this value. This implementation gave the following result on my Windows Vista 64 bit computer for integer value - 4375221. The values can differ if we take int64 instead of signed integer in the above example.

Recursion in Delphi!

2011-07-21T11:21:00.000-07:00

Recursion is a very generically used term in computer programming. Some problem in computer programming which allow repetition of some particular task again and again with some terminating check can be implemented very easily with the help of the concept of recursion.

A simplest example is to find the factorial of 5. The result is derived as -

5! = 5 X 4 X 3 X 2 X 1

5! = 120

This simple program can be easily designed using recursion or using recursive calls to the same function again and again. e.g. -

fact() = fact(i) X fact(i - 1)

The above expression at each step calls the factorial function again with one value less for variable i in each call.

A simple Delphi program to demonstrate the recursion concept in Delphi is as follows -

A button click is used to trigger the recursive function -

procedure TForm1.Button1Click(Sender: TObject);

var
a : integer;
begin

a := fact(5);

    ShowMessage(inttostr(a));
end;

and the simple recursive function is -

function fact(i : integer) : integer;

begin
    if (i = 1) then
    begin
        fact := 1;
    end
    else
    begin
        fact := i * fact(i - 1);
    end;
end;
As we can see in the above example fact function calls itself till the value of i variable reaches 1 which is the terminating condition for our recursive function and no further recursions are made.

The result returned for above example is 120.

Does multiple inheritance exists in Delphi?

2010-10-23T06:36:00.001-07:00

Sometimes it is asked - Delphi supports multiple inheritance or not?

and the answer which usually comes out is - Yes via interfaces, but the problem here is can we really say that implementing an interface actually achieves multiple inheritance in real sense or is it something else. Well the answer to this confusion is that 'No' we cannot say that implementing an interface is a way to achieve multiple inheritance because the first promise that multiple inheritance or inheritance in itself wants is that not only the declaration but also some of the behaviour should get inherited by the child class from the parent class/classes else just by suggesting a declaration of what should be achieved by a child class can never be inheritance. It is as simple as considering the analogy a child inherits some features from both mother and father but its never that a implementation is not inherited from any of the two.

Using interfaces is simply a way of allowing a boundation to the inheriting class to implement certain features so that it meets certain criteria nothing more than that. So the only language to implement multiple inheritance successfully in its real sense is C++ as of now and as per my knowledge. Delphi goes the way Java or C# tried to achieve the similar functionality via interfaces.

Difference between Method pointers and procedural pointers

2010-10-23T06:28:00.000-07:00

While I was having some talk with my friends we ended up into a confusion as what exactly is the difference between the method pointers and procedureal pointers in Delphi and how it can be understood well. Well for a seasoned professional may be the answer to it is quiet easy but it took sometime before we really hit on the answer.

Method pointers are basically pointers to a method which is related to a class and as it is related to a class hence Delphi does pass on the 'Self' implicitly to the method so that the object can be referred to within the method pointed to by the method pointer. In case of a procedural pointer this 'Self' is what is missing and hence we can't have a procedural pointer refer to a class method.

This could be easily remembered the way a class method is defined -

MyClass.MyProcedure;

In this was we can see that we actually have MyClass which suggests that MyProcedure belongs to it. A normal procedure would be defined in this way -

MyProcedure;

suggesting that there is no class to which it belongs and hence no 'Self'.

Is Application Object a window in Delphi?

2010-06-20T01:48:00.000-07:00

Often sometimes while working in Delphi I wondered whether the Application object itself is a window or not.. and if so then where exactly is this window and why is it not visible? Going through Marco Cantu's Mastering Delphi book I found that yes infact Application object in delphi is infact a window but than this fact drove me into curiosity to just see this window visibly and hence I thought of programming a bit on this fact. Though Marco suggested that the best way to see that "Application object is infact a window" is to run Delphi, select "New Application" which creates a new windows application and gives Form1 as a default form and then simply press the Run button. Now on looking into the task bar we are see that the title for our new application is getting displayed as Project1 and not Form1 which clearly suggests that there is infact a hidden window in our newly created windows application. This hidden window is none other than very own Application window but still if we could see the window well stretched on our desktop then it would be a better confirmation to this fact after all to see it clearly is better than mearly realising a fact... Am I Correct? So here we go..

Now to start with - first here is a bit of delphi lecture - If we will look at how TApplication has been defined in Delphi then we find that the class has been inherited from TComponent class but than on going through the class definition we find that Application object infact allows programmer to have access to its handle value.. Handle in itself is a unique 32bit (for 32 bit systems) number that windows OS assigns to each window that will be handling any sort of windows messaging.

Once while I was going through some VC++ lessons and VB programming I once read that if we have access to the handle value fo a window we can manipulate that window to the maximum extent via the windows API's and hence I plan here to do the same to make the "Application Object" show its coordinates and make itself visible...

(Please note that according to Delphi standards all the visible components etc are derived from TControl or TWinControl and not from TComponent and hence if TApplication is invisible to us then it is pretty much cool with us.. but this program is just to show that a delphi program is actually having two windows running at the same time.. one the master which is TApplication and the other is the MainForm..).

Now no more lectures and we are back to work...
So here is a small program to serve our purpose -

First of all lets start Delphi and create this simple form -

(Please click on the image to enlarge)

and on the OnCreate event of the form1 we will try to display the coordinates of the form and Application object via the use of the API GetWindowRect. The GetWindowRect API is used to find the coordinates of a window as screen coordinates for which a handle number is known. So our API statement will look similar to something like -

GetWindowRect(Form1.Handle, FormRect); for form1 and similarly GetWindowRect(Application.Handle, AppRect); for Application object window, where FormRect and AppRect are of type TRect.

The procedure I have written to do the following and display the same in the edit boxes in the form is as follows -

procedure TForm1.RefreshRectInfo;
var
FormRect : TRect;
AppRect : TRect;
begin
GetWindowRect(Form1.Handle, FormRect);
edtTop.Text := IntToStr(FormRect.Top);
edtLeft.Text := IntToStr(FormRect.Left);
edtRight.Text := IntToStr(FormRect.Right);
edtBottom.Text := IntToStr(FormRect.Bottom);
GetWindowRect(Application.Handle, AppRect);
edtAppTop.Text := IntToStr(AppRect.Top);
edtAppLeft.Text := IntToStr(AppRect.Left);
edtAppRight.Text := IntToStr(AppRect.Right);
edtAppBottom.Text := IntToStr(AppRect.Bottom);

end;

Once the form gets opened up, the user is shown that there are infact two different handles assigned to Application and Form1 and hence suggesting that Application object would be handling different messages and is seperate from form1 though is not visible to us. Also, just check what the Application Windows Coordinates group box values are displaying. For me these values suggested the following -> Top: 384, Left: 683: Right: 683 and Bottom: 384. What does this mean? Well this mean that Application window is actually a ZERO size window on the desktop and hence we are not able to see it. So to make it visible we will be just trying to stretch it a little bit not enough to tear it but enough to make it visible to us... :) ..

Now, when the user clicks on the button - "View Application Window" the Application window will become visible however as the form1 which is the MainForm still remains visible hence the Application window remains behind the form1 window. See the screenshot for the same below -

(Please click on the image to enlarge)

As you can see the values displayed in the Application Window coordinates groupbox of form1 have also changed for the Application window and the application window is getting displayed with a border though it displays a transparent client area.

To remove the form1 window just check the checkbox Hide form1 and the application window will be displayed when the user clicks on the View Application Window button. However keep this in mind that here we can't change the actual behaviour of how delphi treats its MainForm and as we made the MainForm invisible hence the once we minimize the Application Window the MainForm will remain invisible and also the Application Window.

Thus by this small exercise we have been able to show that Application window is actually a window with size Zero and is working behind the scenes.. :) ..

Thats all for now.. Here is the dfm code and the pas file code which I created for this application in Delphi 5.0 -

DFM Code (AppWindow) -

object Form1: TForm1
Left = 192
Top = 122
Width = 506
Height = 232
Caption = 'Form1'
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'MS Sans Serif'
Font.Style = []
OldCreateOrder = False
OnCreate = FormCreate
PixelsPerInch = 96
TextHeight = 13
object lblAppObjHandle: TLabel
Left = 16
Top = 8
Width = 129
Height = 13
Caption = 'Application Object Handle: '
end
object lblFormHandle: TLabel
Left = 16
Top = 32
Width = 72
Height = 13
Caption = 'Form1 Handle: '
end
object edtAppObjHandle: TEdit
Left = 176
Top = 8
Width = 121
Height = 21
ReadOnly = True
TabOrder = 0
end
object edtFormHandle: TEdit
Left = 176
Top = 32
Width = 121
Height = 21
ReadOnly = True
TabOrder = 1
end
object btnViewAppWindow: TButton
Left = 312
Top = 5
Width = 145
Height = 25
Caption = 'View Application Window'
Default = True
TabOrder = 2
OnClick = btnViewAppWindowClick
end
object gbRectCoordinates: TGroupBox
Left = 0
Top = 61
Width = 490
Height = 135
Align = alBottom
Caption = 'Windows Coordinates'
TabOrder = 3
object gbForm1Coordinates: TGroupBox
Left = 2
Top = 15
Width = 239
Height = 118
Align = alLeft
Caption = 'Form1 Coordinates'
TabOrder = 0
object lblTop: TLabel
Left = 8
Top = 24
Width = 25
Height = 13
Caption = 'Top: '
end
object lblLeft: TLabel
Left = 9
Top = 47
Width = 24
Height = 13
Caption = 'Left: '
end
object lblRight: TLabel
Left = 8
Top = 67
Width = 31
Height = 13
Caption = 'Right: '
end
object lblBottom: TLabel
Left = 8
Top = 88
Width = 39
Height = 13
Caption = 'Bottom: '
end
object edtTop: TEdit
Left = 72
Top = 20
Width = 49
Height = 21
ReadOnly = True
TabOrder = 0
end
object edtLeft: TEdit
Left = 72
Top = 42
Width = 49
Height = 21
ReadOnly = True
TabOrder = 1
end
object edtRight: TEdit
Left = 72
Top = 64
Width = 49
Height = 21
ReadOnly = True
TabOrder = 2
end
object edtBottom: TEdit
Left = 72
Top = 86
Width = 49
Height = 21
ReadOnly = True
TabOrder = 3
end
end
object gbAppWindowCoordinates: TGroupBox
Left = 241
Top = 15
Width = 247
Height = 118
Align = alClient
Caption = 'Application Window Coordinates'
TabOrder = 1
object lblAppTop: TLabel
Left = 8
Top = 24
Width = 25
Height = 13
Caption = 'Top: '
end
object lblAppLeft: TLabel
Left = 9
Top = 47
Width = 24
Height = 13
Caption = 'Left: '
end
object lblAppRight: TLabel
Left = 8
Top = 67
Width = 31
Height = 13
Caption = 'Right: '
end
object lblAppBottom: TLabel
Left = 8
Top = 88
Width = 39
Height = 13
Caption = 'Bottom: '
end
object edtAppTop: TEdit
Left = 72
Top = 20
Width = 49
Height = 21
ReadOnly = True
TabOrder = 0
end
object edtAppLeft: TEdit
Left = 72
Top = 42
Width = 49
Height = 21
ReadOnly = True
TabOrder = 1
end
object edtAppRight: TEdit
Left = 72
Top = 64
Width = 49
Height = 21
ReadOnly = True
TabOrder = 2
end
object edtAppBottom: TEdit
Left = 72
Top = 86
Width = 49
Height = 21
ReadOnly = True
TabOrder = 3
end
end
end
object cbHideForm1: TCheckBox
Left = 313
Top = 35
Width = 152
Height = 17
Caption = 'Hide Form1'
TabOrder = 4
end
end

Pas Code -

unit AppWindow;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls;

type
TForm1 = class(TForm)
lblAppObjHandle: TLabel;
lblFormHandle: TLabel;
edtAppObjHandle: TEdit;
edtFormHandle: TEdit;
btnViewAppWindow: TButton;
gbRectCoordinates: TGroupBox;
gbForm1Coordinates: TGroupBox;
gbAppWindowCoordinates: TGroupBox;
lblTop: TLabel;
lblLeft: TLabel;
lblRight: TLabel;
lblBottom: TLabel;
edtTop: TEdit;
edtLeft: TEdit;
edtRight: TEdit;
edtBottom: TEdit;
lblAppTop: TLabel;
edtAppTop: TEdit;
lblAppLeft: TLabel;
edtAppLeft: TEdit;
lblAppRight: TLabel;
edtAppRight: TEdit;
lblAppBottom: TLabel;
edtAppBottom: TEdit;
cbHideForm1: TCheckBox;
procedure FormCreate(Sender: TObject);
procedure btnViewAppWindowClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
procedure RefreshRectInfo;
end;

var
Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.FormCreate(Sender: TObject);
begin
edtAppObjHandle.Text := IntToStr(Application.Handle);
edtFormHandle.Text := IntToStr(Form1.Handle);
RefreshRectInfo;
end;

procedure TForm1.btnViewAppWindowClick(Sender: TObject);
begin
SetWindowPos(Application.Handle, HWND_TOPMOST, 10, 10, Screen.Width - 100, Screen.Height - 100, SWP_SHOWWINDOW);
if cbHideForm1.Checked then
ShowWindow(Form1.Handle, SW_HIDE)
else
RefreshRectInfo;
end;

procedure TForm1.RefreshRectInfo;
var
FormRect : TRect;
AppRect : TRect;
begin
GetWindowRect(Form1.Handle, FormRect);
edtTop.Text := IntToStr(FormRect.Top);
edtLeft.Text := IntToStr(FormRect.Left);
edtRight.Text := IntToStr(FormRect.Right);
edtBottom.Text := IntToStr(FormRect.Bottom);
GetWindowRect(Application.Handle, AppRect);
edtAppTop.Text := IntToStr(AppRect.Top);
edtAppLeft.Text := IntToStr(AppRect.Left);
edtAppRight.Text := IntToStr(AppRect.Right);
edtAppBottom.Text := IntToStr(AppRect.Bottom);
end;

end.

A list of popular applications created in Delphi!

2010-01-11T08:07:00.000-08:00

Hi All,

I was going through a lot of discussions in forums and other communities when the discussion turned towards the facts as how many and which popular applications have been created using the Delphi and the answer most were giving was - Skype. Though Skype is indeed a very popular product and ofcourse distributed under Freeware software category however it is not the only product that is popular and has been developed using Delphi. I went through various sites and found a list of such applications created using Delphi. Instead of presenting the same list again at this place here is the link to one such page - http://delphi.wikia.com/wiki/Good_Quality_Applications_Built_With_Delphi
I hope there will be many more such applications that would have been created using this excellent tool but for now above is the list.

Initialization and Finalization Sections of a Unit!

2009-05-14T06:07:00.000-07:00

"Initialization & Finalization Sections - What are they?" - Ever heard of these names earlier while programming delphi application, must have but never bothered much about them.. Guess Right??..

Yes, these two terms are the optional sections of a delphi unit, the common one being the unit header, interface section and implementaion section. However, sometimes we are in a need to perform certain tasks before any of the units code is executed, it is then that we start searching for these two optional sections.

Wheneever we need to do some extra work before any other code is read we place that piece of code in the Initialization section of the unit which is then being called while the application is executed. Now, once this is done and the application needs to terminate then all the resources allocated during the Initialization section of a unit are done free in the finalization section. These two are being declared like this -

unit

interface

implementation

initialization
{Place initialization code here}
finalization
{Place finalization code here}
end.

i.e. before the final end of the unit.

Introduction to Dynamic Link Libraries DLLs.

2008-04-20T01:35:00.000-07:00

Once there was a discussion between me and my friend as why DLL's are required and how to do that in Delphi. So, I thought of demonstrating a very simple program to show how simple it is to create a DLL in delphi.

Dynamic link library or DLL is a collection of routines (i.e. small programs) that can be called by other applications and DLLs.

Dynamic link libraries or DLLs are pieces of sharable codes that various other applications can use. These DLLs contain common code that may be required by different applications to perform similar operations. Thus allowing a single copy of routines to be used by many applications at the same time.

Another advantage of DLLs is that we can safely use routines created in other development environments like VB, C++ to be used in delphi or vice-versa.

Now you must be thinking as how to create a DLL in delphi. Is it really difficult or is it simple?

Well dear developer no need to worry. Its pretty simple in delphi.

Here I will try to create a simple delphi application using a new DLL -
This example will try to do the following for us -

First we will create a DLL that will have methods in it -

First will be a procedure and will display a welcome message.
Second procedure will display a message dialog and will tell us when summation of numbers will start.
Third procedure will also display a message dialog and will tell us when the summation is over and finally,
Fourth will be a function and will actually do summation of two numbers for us and return the result back to our calling program.

The two methods "Welcome" and "sumnumbers" will be called by our delphi application, remaining two are called from inside the sumnumbers function and are for our dll's internal use.

So all set in our mind then lets create our DLL now ->

First open Delphi and select File -> New -> DLL to create a DLL template for us. Then add Dialogs unit to uses portion of the DLL in case it is not already present (This is because I want to show a dialog box in our DLL to highlight the progress). Now, Save the project as MyLibrary.

Well thats not all done, we have to do some more...
But first observe the first line of our DLL. Here , we see that the keyword used is library and not program as in case of form based delphi applications. Well this is because this keyword tells that this is a DLL file and not other delphi application. So, now add the following code to the file -

library MyFirstDLL;

{ Important note about DLL memory management: ShareMem must be the
first unit in your library's USES clause AND your project's (select
Project-View Source) USES clause if your DLL exports any procedures or
functions that pass strings as parameters or function results. This
applies to all strings passed to and from your DLL--even those that
are nested in records and classes. ShareMem is the interface unit to
the BORLNDMM.DLL shared memory manager, which must be deployed along
with your DLL. To avoid using BORLNDMM.DLL, pass string information
using PChar or ShortString parameters. }

uses
SysUtils,
Classes,
Dialogs;

{$R *.RES}

procedure Welcome(); export;
begin
ShowMessage('Welcome to MyLibrary DLL. You are about to view a DLL demo.');
end;

procedure firstmsg();
begin
ShowMessage('Summation is about to start. Please wait');
end;

procedure lastmsg();
begin
ShowMessage('Summation complete. Thanks for using DLL');
end;

// This function will sum two numbers and display result
function sumnumbers(first, second : integer): integer; export;
var
sum : integer;
begin
firstmsg();
sum := first + second;
lastmsg();
Result := sum; // Sending the output back to calling application
end;

exports Welcome, sumnumbers;

begin
end.
Save the project as MyFirstDll. Now compile the DLL project by pressing Ctrl + F9. On compilation a dll file will be created for us in the destination folder (where we saved the project named MyFirstDLL.). So, our dll file is created and the name is - MyFirstDLL.dll.

Now close the project and open a new delphi application by selecting File -> New Application from the main menu. Now add three edit boxes and a button on the form (Hey, I leave the GUI design for you.. :).. ). Now add the following code to your application and save the application (in the same location where we saved our MyFirstDLL.dll application) and the unit as FirstDLLPrj and FirstDLL respectively.

unit FirstDLL;

interface

uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls;

type
TForm1 = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
Edit3: TEdit;
Button1: TButton;
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

var
Form1: TForm1;
procedure Welcome; external 'MyFirstDLL.dll'
function sumnumbers (a, b :integer) : integer; external 'MyFirstDll.dll'

implementation

{$R *.DFM}

procedure TForm1.FormCreate(Sender: TObject);
begin
Welcome;
Edit1.text := '';
Edit2.text := '';
Edit3.text := '';
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
Edit3.Text := inttostr (sumnumbers(strtoint(Edit1.Text), strtoint(Edit2.Text)));
end;

end.

Now all done then we are ready to compile our application. Hey, what are you waiting for press Ctrl F9 and now run the application and Bingo here is our first DLL application created.

Simple isn't it?

Hey, I know what you are thinking now. You must be thinking, "hey hello!! what happened in the above code actually?"

So no need to panic, I will explain what has actually happened above.

First while creating the DLL we did the following - we created two methods (procedure Welcome and function sumnumbers) that we wanted to be used by other applications (These are the common routines that are exported.).

Now to make a procedure or function external i.e. to be used by other applications we have to tag them with export keyword in there definition (see use of export keyword against the procedure Welcome and also against function sumnumbers in code above). The keyword export will tell that the following procedure or function is exportable i.e. could be referenced by outside applications.

The other two procedures firstmsg and lastmsg are for internal purpose (i.e. within our dll and cannot be refered by outside applications) and hence are not tagged with the keywords export.

Finally, to let the compiler know which all are the functions and procedures that are being exported by the DLL we will define the list with exports keyword (see our dll code above) -

exports Welcome, sumnumbers;So, that's all what was required to write a DLL code.

Now coming to the calling application that will actually use this dll and its routines.

To use the DLL routines in our code we have to declare the procedures and functions so that the compiler could find the entry points to these routines. This we did by writing the following code in our calling application -

procedure Welcome; external 'MyFirstDLL.dll'
function sumnumbers (a, b :integer) : integer; external 'MyFirstDll.dll'Above statements have the following portions, (carefully observe these) - first is the name of the procedure as defined in the DLL, then the keyword external telling that the procedure/function is an external function and finally defining the dll file name where the procedure is actually located.

We have used the name of the dll file in our code as the dll was located in the same folder where our calling program is located otherwise we would have to specify the complete path name to access the dll because if the dll won't be located in the same folder we will get an entry point error while running the application.

The entry point error tells that the compiler is not able to find the function or procedure specified in the calling program and so is not able to attach it to our application and execute the routine.

Rest we come to calling and invoking the procedure or function, this is done in the same way as is done for normal procedures and functions in a delphi application. Here it could be noted that we didn't use any special method for invoking the procedures in our code because the dll functions and procedures are now a part of our application.

So, thats it for now. We have finally created our DLL. Now, Enjoy writing more DLL's... My job is done... Astalavista till next article.

Can Objects be assigned to a TStringList?

2008-04-13T06:54:00.000-07:00

Well if someone asks that can we store an object in a TStringlist or should we use only TList for this purpose, the answer should be ----> Yes ofcourse!.

Now how to do that and where can I use such facility. Now first to answer why should we require this feature if at all. One place where we can use such a feature is when we are required to save or associate an object to a particular name, like saving a location name with the corresponding bitmap.

Now coming to how to do that in delphi. The answer is using the Objects property associated with TStringlist. Delphi gives the power of associating objects to tstringlist using this simple property.

Please see the below example to see how to do that -

Here in this example add a button to a simple delphi form. Now add two edit texts and add a TMemo component. Now write the following code on the button click event -

procedure TForm1.Button2Click(Sender: TObject);
var
mystringlist : tstringlist;
begin
Memo1.clear;
mystringlist := tstringlist.create();
mystringlist.Add(edit1.text);
mystringlist.Objects[0] := edit1;
mystringlist.Add(edit2.text);
mystringlist.objects[1] := edit2;
memo1.Lines.Add(TEdit(mystringlist.objects[0]).name);
memo1.Lines.Add(TEdit(mystringlist.objects[1]).name);
end;

Run the delphi program by pressing F9 key or navigating to "Run" Menu and clicking on "Run" Menu item.

Now click on the button on the form and you will see that memo displays two strings edit1 and edit2. Here the names have been derieved from the objects stored in the stringlist.

This was just a demonstration program and the power of such a feature can be easily utilized in performing complex tasks.