Let’s assume that you only want to allow positive integer numbers. The code for the OnKeyPress event handler is as follows:

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
begin
  // #8 is Backspace
  if not (Key in [#8, '0'..'9']) then begin
    ShowMessage('Invalid key');
    // Discard the key
    Key := #0;
  end;
end;

If you also want numbers with a decimal fraction, you must allow a POINT or a COMMA, but only once. For an international version that looks at the correct decimal separator, the code could be as follows:

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
begin
  if not (Key in [#8, '0'..'9', DecimalSeparator]) then begin
    ShowMessage('Invalid key: ' + Key);
    Key := #0;
  end
  else if (Key = DecimalSeparator) and
          (Pos(Key, Edit1.Text) > 0) then begin
    ShowMessage('Invalid Key: twice ' + Key);
    Key := #0;
  end;
end;

And here's a full blown version of the event handler, accepting a decimal separator and negative numbers (minus sign: only accepted once, has to be the first character):

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);
begin
  if not (Key in [#8, '0'..'9', '-', DecimalSeparator]) then
    ShowMessage('Invalid key: ' + Key);
    Key := #0;
  end
  else if ((Key = DecimalSeparator) or (Key = '-')) and
          (Pos(Key, Edit1.Text) > 0) then begin
    ShowMessage('Invalid Key: twice ' + Key);
    Key := #0;
  end
  else if (Key = '-') and
          (Edit1.SelStart <> 0) then begin
    ShowMessage('Only allowed at beginning of number: ' + Key);
    Key := #0;
  end;
end;

How about giving that same behaviour to several TEdits on the same form, say 10 of them? In the Object Inspector, you change the name of the event handler of Edit1 from Edit1KeyPress toEdit1_10KeyPress or something similar. Delphi automatically changes the name in the code editor, don’t worry.

Then, for each next TEdit, you select its OnKeyPress event and you select Edit1_10KeyPress from the listbox next to the event.

Finally, we have to slightly adapt the code. Intead of pointing to Edit1, we must point to “the TEdit that generated the event”, in other words: the edit-box where the cursor was when a key was depressed. When you look at the template for the event handler that Delphi made, you see the parameter Sender: that’s a pointer to the component that generated the event. But we are not allowed to use it straight away in our code, we must specify that we’re dealing with a component of the type TEdit. That’s done with the code Sender as TEdit:

procedure TForm1.Edit1_10KeyPress(Sender: TObject; var Key: Char);
begin
  if not (Key in [#8, '0'..'9', '-', DecimalSeparator]) then
    ShowMessage('Invalid key: ' + Key);
    Key := #0;
  end
  else if ((Key = DecimalSeparator) or (Key = '-')) and
          (Pos(Key, (Sender as TEdit).Text) > 0) then begin
    ShowMessage('Invalid Key: twice ' + Key);
    Key := #0;
  end
  else if (Key = '-') and
          ((Sender as TEdit).SelStart <> 0) then begin
    ShowMessage('Only allowed at beginning of number: ' + Key);
    Key := #0;
  end;
end;

When you want to run a lengthy process in your application that needs no user interaction, you can change the value of the Screen.Cursor property to have the mouse cursor display as a hourglass, for example, while the process is being executed.

The Screen.Cursor property of the global Screen object has a global effect. It controls the cursor shape for all the forms, and the controls on the form, in the application.

When you change the global screen cursor, the user can still click any buttons on the form but visual appearance of the cursor does not imply so.

When you “surround” a consuming / critical operation with a global cursor change, you might want to have one button act as a cancel button, where the click to this button would stop the process.

Since the Screen.Cursor will affect all the controls on the form, you might want to make sure that this “cancel button” displays a “normal” cursor when the mouse pointer is over it.

Note that in the above scenario I’m not taking about the Cancel property of a Button which determines whether the button’s OnClick event handler executes when the Escape key is pressed.
I’m talking of a button that when clicked will stop the lengthy process.

Force Button.Cursor to “Override” Screen.Cursor

 Screen.Cursor := crHourglass; try   // Do some 

"lengthy operation"   //have a button, btnCancel that can stop this operation 

finally    

Screen.Cursor := crDefault; 

end; 

If the “lengthy operation” does not block message processing completely your “cancel” button will be clickable. To ensure messages are not blocked you can call Application.ProcessMessages in intervals, if the process is being executed in the main thread of the application.

While the lengthy process is being run your btnCancel will display a hourglass when the mouse cursor moves over it – since crHourglass is globally set by the Screen object.

If only for this button you want to display some other cursor shape, the one set using that button’s Cursor property, you can hijack the Tag property of the button to set the cursor shape when the mouse enters its client area and set it back to global Screen value when the mouse exits its client area. Here’s how:

 //"cancel" button OnMouseEnter event handler 

procedure TOperationForm.btnCancelMouseEnter(Sender: TObject) ; 

begin   //store current 

screen.cursor value   

btnCancel.Tag := Screen.Cursor;   //temporary set screen.cursor   

Screen.Cursor := btnCancel.Cursor; 

end; //"cancel" button OnMouseLeave event handler 

procedure TOperationForm.btnCancelMouseLeave(Sender: TObject) ; 

begin   //restore current screen.cursor value   

Screen.Cursor := btnCancel.Tag; 

end; 

The above code presumes you are not already using the Tag property of the cancel button to store some other data.

The OnMouseEnter event handler is used to store the current value of the global mouse shape in the Tag property of the button. Screen.Cursor is set to the value of the button’s Cursor property.

The TCursor is defined as type TCursor = -32768..32767, and Tag is an integer property, you can safely store the value of Cursor to the Tag property.

When the mouse leaves the button, the Screen.Cursor is restored.

A neat trick. For a more global solution, you might want to create your own button and store the global cursor value in some integer type property.

Delphi 2009 adds Generics and Anonymous methods to the Delphi language.

When you have objects in some list – one of a commonly required tasks is to sort the list: either ascending, descending or using some list-specific algorithm.

Using anonymous methods you can apply the sorting function directly “inline” with the call to the Sort method.

TList<integer>.Sort(IComparer)

Suppose you have a list of integer numbers. Your task is to sort the numbers in the list.

Here’s the code:

 uses generics.defaults, generics.collections,...

...

type   TIntegerComparer = TComparer<integer>;

...

var   lg : TList<integer>;

n : integer;

begin

lg := TList<integer>.Create;

try

lg.Add(2) ;

lg.Add(4) ;

lg.Add(3) ;

lg.Add(4) ;

lg.Add(5) ;

lg.Add(1) ;

//will display 2,4,3,4,5,1

for n in lg do ShowMessage(IntToStr(i)) ;

//default ascending comparer

lg.Sort(TComparer<integer>.Default) ;

//will display 1,2,3,4,4,5

for n in lg do

ShowMessage(IntToStr(i)) ;

//descending using an anonymous method

lg.Sort(TIntegerComparer.Construct(

function (const L, R: integer): integer

begin

result := R - L;

end ;

//will display 5,4,4,3,2,1

for n in lg do ShowMessage(IntToStr(i)) ;

finally

lg.Free;

end;

end;

Note: the TList<T>.Sort methods expects an IComparer<T> object. IComparer<T> is an interface defined in the generics.defaults unit.

TComparer, also defined in the Generics.Defaults, is an abstract base class for IComparer<T> implementations.

The Construct method of the TComparer<T> is a class method defined as:

 class function Construct(const Comparison: TComparison<T>): IComparer<T>; 

The above returns an IComparer<T> we need for the Sort method AND accepts an anonymous method:

 TComparison<T> = reference to function(const Left, Right: T): Integer; 

Finally, you have a Sort method with an anonymous method as “parameter”:

 lg.Sort(TIntegerComparer.Construct(   function (const L, R: integer): integer   

begin     

result := R - L;   

end ; 

For a non-generic TList object: How to sort items in a TList object.

An enumerated type in Delphi, or enum lets you define a list of values. The values have no inherent meaning, and their ordinality follows the sequence in which the identifiers are listed.

For example, the Align property most Delphi controls expose is of type TAlign which is an enum type defined as

TAlign = (alNone, alTop, alBottom, alLeft, alRight, alClient, alCustom)

Another example is the ViewStyle property of a TListView. ViewStyle determines the visual display of items in a list view. The items can be displayed as a set of movable icons, or as columns of text.

The TViewStyle enum is defined as:

TViewStyle = (vsIcon, vsSmallIcon, vsList, vsReport)

Round Robin Cycling Through Enum Values

If you need to allow a user of your application to change the display of the ListView at run-time, you need to provide some sort of “selectable” user interface. You can choose to display enumerated properties in a selectable list.

If you want to cycle through the possible set of values defined by an enum, you can implement a so called “round robin” algorithm.

From the user interface point of view, you could have a button that when clicked changes, by “increasing” the current value, the current ViewStyle of a list view.

Here’s how to cycle through enumeration values for any enum:

 //with ListView1 do ViewStyle := TViewStyle((1 + Ord(ViewStyle)) mod (1 + Ord(High(TViewStyle)))) ; 

The above code cycles through the TViewStyle enumeration by assigning an increased value to the ViewStyle property.

The above cycling can be used for any enumeration type – just make sure what’s a property and what’s a type declaration, in this code snippet

Have you ever needed for a specific Delphi control, like a TButton, to have just one more property or a method that is a “must have” for your current application?

Experienced Delphi developers, when they need a TMySuperButton, would either look for a third-party VCL solution or would try creating a derived control.

What if you do not want to have this MySuperButton permanently in the Component/Tool Palette – since it solves one problem only for this particular application you are developing?

What’s more … how about having a TButton with more properties and methods, some application specific extra behavior, and not TMySupperButton? How about extending what TButton has without the need to create a derived class with a different name?

You could think now of class helpers, but class helper allow only class methods to be added to a class.

What most beginners do not know is that they *can* create their own custom controls derived from the existing VCL set by creating a, so called, interceptor class that has the same name as the class being extended.

Delphi Interceptor Classes

First, to have two classes with the same name is possible in Delphi if those two classes are in separate units.

Next, the following declaration is legal

 type TButton = class(StdCtrls.TButton) 

The above code creates an interceptor class for a TButton control by extending the “original” TButton declared in the VCL’s StdCtrls unit.

Finally, the above declaration needs to be placed in a separate unit.

Most important, the unit hosting the interceptor class needs to be listed in the uses clause *after* the unit defining the base class.

TButton = class(TButton) – an Interceptor Class Example

Here’s one interceptor class for the TButton.

A public property “LastClickTime” is added. The original TButton’s Click procedure is overridden – Click raises the OnClick event.

Using the overridden Click procedure our TButton interceptor will not allow running the OnClick event handler if the last click on the button happened during the last two second, only a Beep sound will play.

Ok, a dummy example, but serves the purpose. Download an example project: TButton interceptor.

 unit button_interceptor; interface uses stdctrls, sysutils, DateUtils; type   TButton = class(stdctrls.TButton)   private     fLastClickTime: TDateTime;   public     procedure Click; override;   public     property LastClickTime : TDateTime read fLastClickTime write fLastClickTime;   end; implementation procedure TButton.Click; const   ClickWaitPeriod = 2; var   clickTime : TDateTime; begin   clickTime := Now;   if SecondsBetween(clickTime, LastClickTIme) > ClickWaitPeriod then      inherited   else     Beep;   LastClickTime := clickTime; end; end. 

Now, drop a standard button (TButton) on a Delphi form. Attach some event handler to its OnClick event.

Most importantly, add the “button_interceptor” unit in the uses list as the last unit listed, or at least after the “stdctrls” unit!

Try clicking the button – note that the code executes only if you wait for two second after the last click.

That’s it. Using the above you can easily extend Delphi classes by adding extra properties and methods – without the need to create derived classes and have them in the component palette.

Ah almost forgot: note that when you type “Button1.” and the list of button’s properties and methods pops up – you see the added “LastButtonClick” as if it belongs to the standard Delphi’s TButton. Delphi (compiler) magic

Also note that you can use interceptor classes not only to extend VCL controls but to extend any Delphi class.

If you need to fake creating your own inherited VCL control, take a look at Fake Creating a New Delphi Control.

Delphi’s TToolBar control manages tool buttons, TToolButton controls. Typically, the tool buttons correspond to items in an application’s menu and give the user more direct access to the application’s commands.

Depending on the Style property of the button placed on a tool bar, a button, a drop down button, a text button or a divider will be displayed to the user. Tool buttons can act like regular push buttons; toggle on and off when clicked and can act like a set of radio buttons.

Style = tbsDropDown and the OnClick event

When tool button’s Style is set to tbsDropDown, the button displays a down-pointing arrow (suitable for accessing a drop-down menu). When its DropDownMenu points to an instance of aTPopupMenu - the button when clicked will display the popup menu associated.

The actual popup menu will get displayed ONLY when you click the down-pointing arrow.

If a user clicks on the button itself and not on the down-pointing arrow – the popup menu will NOT get displayed.

Display the Drop Down Menu when ToolButton is Clicked “Anywhere”

To make sure that the drop down menu gets displayed when you click on the button, as opposed to clicking on the down-pointing arrow, you need to handle button’s OnClick event and force the display of the popup menu associated.

Fortunately, there’s a CheckMenuDropdown method of the tool button that you can call to manually display a button’s pop-up menu. It returns true and displays the menu if the tool button has an associated menu. It returns false if there is no menu to display.

 //ensure DropDownMenu Popup to pop up when button is clicked. 

procedure TForm.dropDownMenuButtonClick(Sender: TObject) ; 

begin   

//dropDownMenuButton is the name of the tool button   

//with Style set to tbsDropDown and assigned DropDownMenu   dropDownMenuButton.CheckMenuDropdown; 

end;

The number system in most common use today is the Arabic system. The ten single-digit numerals, “0″ through “9″, make up the symbols of our numbering system. An example of a different numeral system is the system of Roman numerals, which could represent all the numbers from 1 to 1,000,000 using only seven symbols: I = 1, V = 5, X = 10, L = 50, C = 100, D = 500, M = 1000. Example: 1973 (Arabic) is MCMLXXIII (Roman).

Delphi MMIIX

Converting from 2009 to MMIX is easy, an algorithm is provided in How to convert numbers from one base to another.

How to convert a roman number to its arabic representation?

Here’s a Delphi function that does the job:

 function RomanToArabic(const romanNumber : string) : integer ; 

const   romanChars = 'IVXLCDMvxlcdm?!#' ;   decades : 

array [0..8] of integer = (0, 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000) ;   

OneFive : array [boolean] of byte = (1, 5) ; 

var   newValue, oldValue : integer ;   

cIdx, P : byte ; 

begin   result := 0;   

oldValue := 0 ;   

for cIdx := Length(romanNumber) downto 1 do   

begin     P := Succ(Pos(romanNumber[cIdx], romanChars)) ;     

newValue := OneFive[Odd(P)] * decades[P div 2] ;     

if newValue = 0 then     

begin   result := -1;       

Exit;     

end ;     

if newValue < oldValue then 

newValue := - newValue ;     

Inc(result, newValue) ;     

oldValue := newValue   

end ; 

end; 

Note: RomanToArabic would return -1 if the “romanNumber” parameter is *not* a roman number (for example “MIXKIX” is not a roman number).

If Douglas Adams was in Rome at the time of writing his Guide, the definitive answer would probably be XLII

You’ve certainly seen “#13#10″ many times in Delphi source code. If you are wondering what those characters stand for, here’s the answer:

A control string is a sequence of one or more control characters, each of which consists of the # symbol followed by an unsigned integer constant from 0 to 255 (decimal or hexadecimal) and denotes the corresponding ASCII character.

When you want to, for example, assign a two-line string to a Caption property (of a TLabel control), you can use the following “code:”

Label1.Caption := ‘First line’ + #13#10 + ‘Second line’;

The “#13#10″ part represents a carriage-return + line-feed combination.

The “#13″ is the ASCII equivalent to the CR (carriage return) value; #10 represents LF (line feed).

Two more interesting control characters are:
#0 – NULL character and
#9 – (horizontal) TAB

Note: here’s how to translate a virtual-key to ASCII code.

When working on database applications using dbGO (ADO) over SQL Server or MS Access, you might be having troubles formatting the SQL string expression used in various INSERT, UPDATE or SELECT statements.

Here are some issues:

1. Depending on locale international settings date values, for example, when transformed to string values might not be formatted properly. Delphi RTL’s function DateTimeToStr might return a date value as ‘DD.MM.YYYY’ while a valid SQL expression requires, for example (depending on the Windows international settings), ‘MM/DD/YYYY’.

2. When you need to “construct” a string value to a SQL statement string, you almost always need to use the QuotedStr function (to “fix” the apostrophe “‘” character issue).

3. Last (but not the least), SQL Server expects “.” (dot) for the decimal separator when formatting decimal values. Some countries use “,” (comma) for decimal separator. A simple FloatToStr will not do the trick.

With the above in mind, when you have many SQL expressions to create, a simple SQL like the following can turn into a nightmare (to create a valid INSERT statement):
‘INSERT INTO TableName (IntField, StringField) VALUES (‘ + IntToStr(2005) +’,'+ QuotedStr(‘delphi.about.com’)+’)';

This tends to be even worse when date and money fields and involved.

The TSQLF (SQL Format) “helper” class With the help of the TSQLF class (exposing only class methods), the above SQL expression can be turned into:

‘INSERT INTO TableName (IntField, StringField) VALUES (‘ + TSQLF.Int(2005) + ‘,’+ TSQLF.Text(‘delphi.about.com’) + ‘)’;

And if it turns that you have to correct the way, for example, QuotedStr function operates you only need to change the code in one place (implementation of the TSQLF.Text method).

Here’s the full source of the TSQLF class (unit), taking local settings into account:

~~~~~~~~~~~~~~~~~~~~~~~~~
unit SQLFormat;

interface

uses Windows, SysUtils, StrUtils;

type
TSQLF = class
public
class function Date(const Date : TDateTime) : string;
class function Money(const Money : Currency) : string;
class function Int(const Int : integer) : string;
class function Text(const str : string) : string;
end;

implementation

var fs : TFormatSettings;

class function TSQLF.Date(const Date: TDateTime): string;
var
Year, Month, Day : Word;
begin
DecodeDate(Date, Year, Month, Day) ;

Result := QuotedStr(IntToStr(Year) + ‘-’ + IntToStr(Month) + ‘-’ + IntToStr(Day)) ;
end;

class function TSQLF.Int(const Int: integer): string;
begin
Result := IntToStr(Int) ;
end;

class function TSQLF.Money(const Money: Currency): string;
var
decSep : char;
begin
decSep := fs.DecimalSeparator;
fs.DecimalSeparator := ‘.’;

Result := CurrToStr(Money,fs) ;

fs.DecimalSeparator := decSep;
end;

class function TSQLF.Text(const str: string): string;
begin
result := QuotedStr(str) ;
end;

initialization
GetLocaleFormatSettings(LOCALE_SYSTEM_DEFAULT, fs) ;
finalization
//nothing special in the finalization

end.
~~~~~~~~~~~~~~~~~~~~~~~~~

Whenever memory is allocated for an object, it must eventually be freed (or you’ll produce amemory leak). But with components, there is often little mention of the need to do this. Delphi must be destroying the objects, but how does it know when we’re through with them?

Here’s a hint. TComponent declares the Create constructor as follows:

constructor Create(AOwner: TComponent) ; virtual;

The answer is in the “AOwner” parameter to the Create constructor. The Create constructor is virtual (and is a class method).

Every component that resides on the palette inherits this constructor. Inside the constructor, Delphi creates the component, and if an owner (hint: Owner vs. Parent) is specified (if AOwner is not nil), Delphi adds the newly-created component to the Owner’s internal owned component list.

This internal list is consulted by Delphi for three important events that can affect an owner (e.g., any TComponent descendant):

• A new component is created and added to the internal component list. When this happens, every component on the internal list is notified by calling the virtual method, Notification, passing a reference to the new component and specifying opInsert as the Operation. The Notification method is critical to support component linking.
• A new component is destroyed and removed from the internal component list. When this happens, every component on the internal list is notified by calling the virtual method, Notification, passing a reference to the new component and specifying opRemove as the Operation.
• The owner component is destroyed. When this happens, every owned component on the internal list is destroyed (and any components owned by these components are also recursively destroyed). That’s why you don’t need to explicitly destroy components that are owned, and this is part of what makes programming in Delphi so easy.

The role of the AOwner parameter is even more important when you are creating Delphi components at run-time. If you are creating forms dynamically the AOwner can be set to nil, Self or Application.