In RAD Studio Delphi 32-bit you can use any of the following versions:
/COM indicates the 32-bit edition of the ActiveX version
The application built using /COM version runs on any Windows 32 or 64-bit machine.
In RAD Studio Delphi 64-bit you can use any of the following versions:
/COM/64 indicates the 64-bit edition of the ActiveX version
The application built using /COM/64 version runs on Windows 64-bit machine only. The application built using /COM/64 version cannot run on Windows 32-bit machine.
If you want to use your application on 32 and 64-bit machines, you can go for:
/COM/ANY indicates the 32 and 64-bit editions of the ActiveX versions
This error may occur when a /COM 32 or 64-bit module is being installed by a Delphi package (2010). The EFilerError exception is thrown because a component has already
registered different objects with the same name as the new component you are installing. For instance, a Column object from eXG2antt generates a TColumn, while a Column
object from eXGantt also generates a TColumn. Despite having the same name, they are distinct objects.
Typically, the T... classes are automatically generated as wrapper classes in the PAS extension based on the interfaces or objects provided by the control.
When multiple controls use the same name for their interface, conflicts can arise, but this can be resolved by renaming.
At the end of each ..._TLB.pas file you intend to install, you will usually find something like:
All you need to do is globally replace each word in [] of dtlServerPage (check the Options: Case Sensitive, Whole word only and Scrope: Global) as 'TColumn', 'TColumns', ... with 'TColumn_Gantt', 'TColumns_Gantt', ... until you achieve the following:
The installation is considered successful only when the message 'Package ...\Bpl....bpl has been installed. The following new component(s) have been registered: ....' appears.
If you have Visual Code installed, you can replace all of these simultaneously by following these steps:
drag or open the ..._TLB.pas file into Vsiual Studio
Press CTRL + H to open the Replace dialog and :
at the Find field paste: \b(TColumn|TColumns|TItems|TOleEvent|TOleEventParam|TAppearance|TExDataObjectFiles|TExDataObject|TTemplate|TTemplatePage|TChart|TLevel|TBar|TBars|TConditionalFormat|TConditionalFormats)\b, !!! don't forget to check Match Case (Alt+C), Match Whole Word(Alt+W) and Use Regular Expression(Alt+R)
at the Replace field paste: $0_Gantt
click Replace All(Ctrl+Alt+Enter)
Be cautious with TColor, as it can be:
a type that represents colors and is used throughout the VCL (Visual Component Library) to specify color properties. It is typically an integer type and can represent standard colors, custom colors, or system colors.
is the class wrapper for the LColor object in the eXGauge component. The LColor object holds details about a solid or EBN (Enhanced Background) color that appears on the layer's background.
In this case, replace TColor with TColor_ExGauge, except for properties such as:
procedure DisableFpu;
begin
Set8087CW(Default8087CW or $3F);
end;
"This is not so much a bug as an incompatibility between different
compilers. There's a detailed explanation below. In short, what happens is
that Delphi and C++Builder set the control word of the processor to a
certain state, and applications or dlls written in Visual C++, for example,
set it to a different state. This causes crashes (more precisely: floating
point division by zero exceptions)."
This error could appear when a /COM 32 or 64 bits module is hosted by a Delphi application ( 2007, 2009, 2010, 2024 ). This error does not occur in Delphi 8.
The EVariantBadVarTypeError is the exception class for variant type errors. The EVariantBadVarTypeError is raised when a variant operation fails because of a value that isn't a valid variant type
The Delphi is not able to handle the events of Variant type, so the generated TLB file requires some changes for events that carries parameters of the Variant type, events such as BarResize, BarResizing, BarParentChange and so on. Running a sample with such of event handled, fires "Project raised exception class EVariantBadVarTypeError with message 'Invalid variant type'. Process stopped. Use Step or Run to continue."
In order to prevent this, you can use the
Event
handler and the EventParam
properties to handle the BarResize event instead. For instance, the
Event(120) is fired when the BarResize event occurs. The EventParam(0)
gets the handle of the item where the bar is resized, and the
EventParam(1) gets the key of the bar being resized. The EventParam
property has effect only if it is called during the event itself.
Calling outside the event, has no effect.
Change or make the following adjustments in the BarResize defintion.
So, let's assume that we are handing the
eXG2antt's BarResize
event which definition is:
event BarResize (Item as HITEM, Key as Variant)
There are three things you need to do so the BarResize is properly fired
as follows:
change the TG2anttBarResize to TNotifyEvent in TLB file, so there is
no parameter of OleVariant type.
update the definition for the generated event to procedure G2antt1BarResize(ASender:
TObject); with no parameters. You have to use the EventParam
property to access the event's parameters.
assign the new event to OnBarResize property during the FormCreate
event of the form.
Here's the changes in detail.
The Delphi generates the event BarResize as a property OnBarResize with
following syntax:
The G2antt1BarResize method referenced by G2antt1.OnBarResize has an incompatible parameter list. Remove the reference?
Click Yes, so the reference is removed as you will assign the event at
runtime, in order to prevent showing this message.
Now, the last thing we have to do is to assign the new event handler for
the OnBarResize property ( call this on TForm1.FormCreate(Sender: TObject)
event )
G2antt1.OnBarResize := G2antt1BarResize;
Save, and run the project. The BarResize event will be fired, and the
EventParam property can be used to access the event's parameters without any
error.
In conclusion the BarResize event may show as following:
procedure TForm1.G2antt1BarResize(ASender: TObject);
var s : String;
begin
with G2antt1 do
begin
s := 'Item: ' + VarToStr(EventParam[0]);
s := s + ' Key: ' + VarToStr(EventParam[1]);
MessageBox(0,PChar(s),'Parameters',0);
end
end;
You can use the EventParam to change a specified parameter, if you are
calling something like EventParam[Index] := Value; For this, you have to
make sure that the parameter is passed by reference ( it is preceded by a
var keyword ).
This error could appear when pasting code from the exontrol's exhelper
tool. The problem is that the wrapper of the control renamed the Label
property/parameter to Label_. At the top of the control's TLB file you
will find a list of Hint that indicates the changes. For instance for label
you will find: "Hint: Member 'Label' of 'IChart' changed to 'Label_'
"
Drag-and-drop is one of the fundamental metaphors underlying the Microsoft�
Windows family of operating systems. Users understand that some items can be
moved around by holding the mouse down on them, and that they'll get appropriate
visual feedback when they're over a spot where the item can be dropped. They
expect to be able to move data and images from one spot to another this way.
By default Delphi implements its own drag and drop events for TControl
objects so these events override the OLE drag and drop events of the
components. In conclusion, you have to use the Delphi's default implementation
for drag and drop events.
There are three simple steps required in order to be able to drag and drop
items/objects/bars from our /COM components as follows:
Beginning a Drag-and-Drop Operation
To begin a drag-and-drop operation, you have to call the BeginDrag
method of the TControl object, when the MouseDown event is fired.
Accepting Data From a Drag Operation
The control fires the StartDrag event, when the user hovers data to the
control so the Accept parameter of the event should be changed accordingly.
Performing the Drop Operation
The control fires the DragDrop event when the user drags data inside the
control, so you need to handle the DragDrop event.
In conclusion, here's a simple Delphi sample that allows moving the items
from an item to another, using Drag and Drop:
procedure TForm1.G2antt1MouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var h : Integer;
var c : Integer;
var hit : EXG2ANTTLib_TLB.HitTestInfoEnum;
begin
with G2antt1 do
begin
h := ItemFromPoint[-1, -1, c, hit];
if ( h <> 0 ) and ( c <> -1 ) then // Begins drag and drop operation as soon as we drag an item in the list area, not the chart area
begin
BeginDrag(False);
end;
end;
end;
procedure TForm1.G2antt1DragOver(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
begin
Accept := Source IS TG2antt;
end;
procedure TForm1.G2antt1DragDrop(Sender, Source: TObject; X, Y: Integer);
var h, hDragged : Integer;
var c : Integer;
var hit : EXG2ANTTLib_TLB.HitTestInfoEnum;
begin
with G2antt1 do
begin
hDragged := Items.FocusItem;
h := ItemFromPoint[-1, -1, c, hit];
if ( h <> 0 ) then
begin
BeginUpdate();
with Items do
begin
SetParent(hDragged,h);
ExpandItem[h] := True;
SelectItem[hDragged] := True;
end;
EndUpdate();
end;
end;
end;
The following trick helps you to forward the message to inside editor, while editing, instead navigating to another cell:
procedure TfmMainForm.G2antt1KeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
var
AHandle:HWND;
begin
AHandle:=G2antt1.Editing;
if AHandle<>0 then
begin
if (Key=VK_LEFT) or (Key=VK_RIGHT) then
begin
SendMessage(AHandle,256,Key,0);
Key := 0;
end;
end;
end;
The sample checks if the control is in editing mode, and forwards the
left or right arrow to inside editor.
The same idea is applied for Backspace key, instead that the KeyPress
event must be handled such as:
procedure TForm1.G2antt1KeyPress(Sender: TObject; var Key: Char);
var
Edit: HWND;
begin
Edit := G2antt1.Editing;
if Edit <> 0 then begin
if Ord(Key) = VK_BACK then begin
if not FSendingBackspace then begin
FSendingBackspace := True;
try
SendMessage(Edit, WM_CHAR, VK_BACK, 0);
Key := #0;
finally
FSendingBackspace := False;
end;
end;
end else begin
//handling other keys...
end;
end;
end;
The sample checks if the control is in editing mode, and forwards the backspace key to inside editor.
This is happen, because the TLB files were not re-generated after buying and
installing the registered version of the component.
In order to prevent the problem, you need to
install the registered setup on your development machine
re-create the wrappers of the TLB files on the development machine
include the new regenerated files to your project
Also you can do the following:
remove the control from the form, and then re-add it, so you make sure
that the registered version is shown on the form ( no warning bar is
shown ).
verify that the used TLB file include a @CLicenseKey ( InitControlData
procedure ), else it means that the TLB file were generated using the
trial version.
The most common cause of happing this is that you have started developing
your application using the trial version of the component, not using the
registered version.
Please do the following test on your DEVELOPMENT machine:
Install the registered version you have received from us once you
purchased the component.
Start Delphi, and creates a new project
Select the Component\Import ActiveX Control... and then select the
control you want to include in the project, let's say the ExG2antt 1.0
Control Library ( Version 1.0 ), and then click the Create Unit
If the message to "Do you want to replace it?" shows up,
click Yes, so the new TLB file is regenerated.
In the TLB file you can search for the @CLicenseKey, and if this is
found, you can go to the next step.
Install the component by selecting the Component\Install Component...,
click the Into new package, and select the new TLB file you were
generated earlier. Type the new name of the package in the Package file
name. Click OK.
If the message to "Do you want to replace it?" shows up,
click Yes
If the message to "Package ... will be built then installed.
Continue?" shows up, click Yes
Go to the Form in design mode, and then select the ActiveX palette
tool, so you can select the component to be inserted to the form. Select
the component from the toolbar, and place it to the form.
Save the project
Build All the project, so the EXE file is generated in the folder
where you have saved the project,
Close Delphi.
On the CLIENT machine do the following:
Copy the DLL file ( aka ExG2antt.dll ) and the EXE file you were built
earlier from the development machine on the client machine
Call the regsvr32 on the DLL (aka regsvr32 ExG2antt.dll ), so the DLL
is registered on the client machine. You are NOT allowed to install any
development setup on the client machine. Only a regsvr32 it is required,
so the message "DllRegisterServer in ....dll succeeded." is
displayed.
This is happen, if you are setting the DataSource property to the reference
of the TADOTable, TADODataSet, ... object ( wrappers ), instead reference to
the Recordset property of TADOTable. The Delphi environment provides wrapper
objects like TADOConnection, TADODataSet, TADOTable to facilitate accessing
a database, tables, and so on. Internally, the TADOTable, TADODataSet, uses
"ADODB.Recordset" type library. The Recordset property of the
TADOTable object returns a reference to the "ADODB.Recordset" type
library which is required by the control's DataSource
The control's DataSource property binds the control to an ADO or DAO recordset.
In other words, the columns section of the control requires a table/recordset
to fill data from. When the DataSource property is set, the recordset being
passed, must be opened or active, so the control can load data from, and
sink to the recordset events.
Calling the following:
G2antt1.DataSource := ADOTable1
gets the error "E2010 Incompatible types: 'IDispatch' and 'TADOTable'",
The Active property on True, makes sure that the recordset is opened
before calling the DataSource property. If the recordset is not opened,
before calling the DataSource, the control loads no data, and it may returns
an error: 0x80020009.
If using the eXGantt or eXG2antt, you want to
fill the Chart section too, so all you need is to add an AddItem handler,
with a code like:
// AddItem event - Occurs after a new Item has been inserted to Items collection.
procedure TForm1.Gantt1AddItem(ASender: TObject; Item : HITEM);
begin
with Gantt1 do
begin
with Items do
begin
AddBar(Item,'Task',CellCaption[OleVariant(Item),OleVariant('Start')],CellCaption[OleVariant(Item),OleVariant('End')],Null,Null);
end;
end
end;
which actually loads a Task bar for each record found, using the
Start/End columns in the recordset. You should change accordingly the
name of the Columns with your case. In conclusion, the AddItem event is
fired once a new item/record is loaded from the recordset.
You can use the Items.AllowCellValueToItemBar
property to associate a column with a property of the bar, so you can
have the value of the starting/ending position of the tasks into columns
section, and so automatically serialized to the database, once a change
occurs.
Handle the Error
event, to be notified if any ADO or DAO error occurs while using the
DataSource property.
An application is considered an isolated application if all of its components are side-by-side assemblies. A side-by-side assembly is a collection of resources?a group of DLLs, windows classes, COM servers, type libraries, or interfaces?available for an application to use at runtime. Typically, a side-by-side assembly is one to several DLLs.
Isolated COM allows your application to use ActiveX components without having to register them. The original vision of this was to allow copy deployment of the application, but Isolated COM has many benefits. You can have a private copy of the DLL without worrying that another application will install an older or newer copy that breaks your application. Isolated COM also allows you to successfully install and run on non-Administrator accounts.
The
solution is to include the control's manifest file to the application's
resource under 24( Manifest Resource Type ) with the identifier 1.
Open the Project\Options
Go to Application
Select at Runtime Themes field the "Use custom manifest"
At the Custom Manifest field fills or select the exg2antt.manifest
file
Build the project
Now, copy the generated EXE and the exg2antt.dll to a client machine, and
run the EXE. It will work, as in this case, the application uses the
exg2antt as isolated, so it requires no registration ( regsvr32 ).
You can download it here
the Delphi XE7 project. In the Release folder, you can find the sample.exe
that uses the exg2antt.dll as isolated.
The eXHelper tool helps you quickly find answers and source code for questions about using our UI components. Currently, the eXHelper tool is not able to generate 100% running code as it lacks of:
Declaring variables (like Dim h As Long in VB6 or var h: Integer in Delphi, etc.)
Some event code in X-Script isn't fully converted to all programming languages
For instance, if your environment generates errors as:
E2003 Undeclared identifier: 'h', You need to declare the specified variable, like var h: Integer
By default, you initialize the control in the FormCreate event, which runs when a form is created. This is where you can set up properties, configure controls, or perform other startup tasks. The following properties of the control:
requires the control to be visible, so they won't take effect. Some parts of the code should be moved to the FormShow event, as shown in the following sample:
procedure TForm1.FormShow(Sender: TObject);
begin
with G2antt1 do
begin
BeginUpdate();
with Chart do
begin
FirstVisibleDate := '9/20/2006';
PaneWidth[False] := 196;
end;
EndUpdate();
end
end;
The following exceptions or errors occur when accessing an event that includes parameters of the OleVariant type:
"Project ... raised exception class $C0000005 with message 'access violation at ...: read of address 0x00000000'", runtime error
"Invalid variant type" runtime exception
"E2064 Left side cannot be assigned to" compiler error
The Delphi environment fails to properly handle events with OleVariant parameters, or generates incorrect definitions for events that use parameters of type "const OleVariant" when they should be declared as "var OleVariant"
The solution is to make a few changes in the TLB file (component package) and reinstall the package for events that include parameters of type OleVariant, as explained below:
for events that carry parameters by value of type OleVariant (error 1 and 2), such as
where the Key/StarBarKey/EndBarKey/NewValue parameter passed by value is declared as Variant, you need to:
open the *TLB.pas (package) file that defines the component
locate the defintion of the event such as "TG2anttBarResize = procedure(ASender: TObject; Item: HITEM; Key: OleVariant) of object" and replace with TG2anttBarResize = TNotifyEvent; or TG2anttBarResize = procedure(ASender: TObject) of object
reinstall the package to receive a confirmation message like 'Package ...bpl has been installed.'
replace the definition of G2antt1BarResize in the PAS file from G2antt1BarResize(ASender: TObject; Item: HITEM; Key: OleVariant) to G2antt1BarResize(ASender: TObject), or remove and add a new event handler (Property and method ... are not compatible)
Now, the event works properly, but to access the parameters, you need to use the EventParam property, as shown in the following example:
procedure TForm1.G2antt1BarResize(ASender: TObject);
begin
ShowMessage('The bar "' + VarToStr(G2antt1.EventParam[1]) + '" of "' + G2antt1.Items.CellCaption[G2antt1.EventParam[0], 0] + '" has been moved or resized');
end;
where EventParam[0] represents the Item parameter (the first parameter of the event as declared in the help file), and EventParam[1] specifies the Key parameter (the second parameter of the event as declared in the help file)
for events that carry parameters by reference of type const OleVariant (error 3), such as
where the Cancel/Value/NewValue parameter passed by reference is declared as Variant, you need to replace the "const OleVariant" to "var OleVariant"
open the *TLB.pas (package) file that defines the component
locate the defintion of the event such as "TG2anttChange = procedure(ASender: TObject; Item: HITEM; ColIndex: Integer; const NewValue: OleVariant) of object;" and replace with "TG2anttChange = procedure(ASender: TObject; Item: HITEM; ColIndex: Integer; var NewValue: OleVariant) of object;"
reinstall the package to receive a confirmation message like 'Package ...bpl has been installed.'
replace the definition of G2antt1Change in the PAS file from G2antt1Change(ASender: TObject; Item: HITEM; ColIndex: Integer; const NewValue: OleVariant) to "G2antt1Change(ASender: TObject; Item: HITEM; ColIndex: Integer; var NewValue: OleVariant)", or remove and add a new event handler (Property and method ... are not compatible)
Now, the event works properly, you can change the parameter during the event, as shown in the following example:
procedure TForm1.G2antt1Change(ASender: TObject; Item: HITEM; ColIndex: Integer; var NewValue: OleVariant);
begin
NewValue := '1234';
end;
where the NewValue parameter can be modified at runtime, as it is passed by reference.
There are two reasons why the component is not listed:
You have installed the 32-bit version while the environment is 64-bit, or vice versa (suggestion: Install both the 32-bit and 64-bit versions of the control)
The control you're trying to use is a windowless control, so you need to import its type library, such as eXContextMenu, eXPopupMenu, eXHTTP, eXPDF, etc.
If you're trying to use a windowless control like eXContextMenu, eXPopupMenu, etc., you need to follow these steps:
Select Component\Import Component
Select 'Import a Type library' from Type of Component list, and click Next
Select 'ExContextMenu 1.0 Type Library' from Registered Type Libraries, and click Next
On Component page that displays the Class Name to add, click Next
Select 'Install to New Package' in Create Unit page, and click Next
Type 'exccontextmenu' into 'Package name' field, and click Finish
After installing the Type library, the message "Package ...\excontextmenu.bpl has been installed." should appear.
The solution is to handle the Application.OnMessage method and pass the WM_KEYDOWN messages to the window that currently has focus, as in the below samples. The Application.OnMessage method allows you to handle or process messages sent to the application's message queue. You can use it to intercept and respond to specific Windows messages before they are processed by the default event handlers.
The following example forwards only the VK_LEFT and VK_RIGHT keys from WM_KEYDOWN messages to the window that currently has focus:
procedure TForm1.MsgHandler(var Msg: TMsg; var Handled: Boolean);
var
key : word;
begin
if (Msg.message = WM_KEYDOWN) then
begin
key := Msg.wParam;
Handled := true;
case Key of
VK_LEFT, VK_RIGHT : SendMessage(GetFocus,Msg.message,key,0);
else Handled := false;
end;
end;
end;
The following sample forwards all WM_KEYDOWN messages to the focused window:
procedure TForm1.MsgHandler(var Msg: TMsg; var Handled: Boolean);
begin
if (Msg.message = WM_KEYDOWN) then
begin
Handled := true;
SendMessage(GetFocus,Msg.message,Msg.wParam,0);
end;
end;
and the OnMessage handler should be changed during OnCreate event as follows:
procedure TForm1.FormCreate(Sender: TObject);
begin
Application.OnMessage := Self.MsgHandler;
end;
where MsgHandler must be declared as "procedure MsgHandler(var Msg: TMsg; var Handled: Boolean);" in Type section
The error E2003 Undeclared identifier: 'ADODB_TLB' typically occurs in Delphi or C++ Builder when the ADODB_TLB unit is not properly referenced in your project. This unit is required to work with ActiveX Data Objects (ADO) in Delphi.
To resolve this issue, follow these steps:
Ensure ADO is installed: Make sure that the ADO components are installed and registered on your system.
Add the ADO library to your project: Import the "Microsoft ActiveX Data Objects 6.1 Library" as descrobed here and add it to your project
Check the unit's namespace: Add ADODB_TLB to the uses section or ensure it is included
The error EVariantTypeCastError with the message "Could not convert variant of type (Null) into type (Integer)" typically occurs in Delphi when trying to cast a Null variant value to an Integer. This can happen when the variant being accessed has a Null value and is being interpreted as an integer or other specific type, which Delphi cannot convert.
Use the value 0 in place of null if no other default value is specified in the method's documentation, so change:
rs.Open('Select * FROM Employees WHERE 1=0','Provider=Microsoft.ACE.OLEDB.12.0;Data Source=' + folder+ '\..\..\Access\sample.accdb',3, 3, Null);
to
rs.Open('Select * FROM Employees WHERE 1=0','Provider=Microsoft.ACE.OLEDB.12.0;Data Source=' + folder+ '\..\..\Access\sample.accdb',3, 3, 0);
The EOleException error with the message "Application uses a value of the wrong type for the current operation" usually occurs in Delphi when interacting with COM objects or ActiveX controls and an unexpected data type is used in an operation or method call.
where rs is variable of ADODB_TLB.Recordset type, and TemplateDef, TemplatePut, Template and PutItems are methods of eXTree, eXGrid, eXGantt, or eXG2antt control.
A ..._TLB.pas file is generated when you import a COM or ActiveX type library into your project. This file, named after the imported type library, serves as a Pascal wrapper that defines the interfaces, classes, and constants of the COM components, allowing Delphi to interact with the COM object in a strongly-typed way.
When the environment generates the ..._TLB.pas file, it includes a Hint section at the top of the file that defines any properties that have been renamed. For example, the following properties are renamed to avoid conflicts with Delphi keywords:
Symbol 'Type' renamed to 'type_' (the Type keyword is used to define new data types)
Symbol 'hWnd' renamed to 'HWND_' (the hWnd (short for "handle to a window") is a unique identifier or handle used to represent a specific window or control within an application)
Member 'End' of '...' changed to 'End_' (the end keyword marks the conclusion of various blocks of code, including procedures, functions, conditionals, loops, and type declarations. It is essential for structuring code properly and signals where each block finishes)
The error "E2037 Declaration of 'Create' differs from previous declaration" can occur when importing the ICalendar type library due to a conflict between the TComponent class in the ICalendar library and the TComponent class in Delphi. The TComponent class in Delphi is a foundational class used for building components in Delphi applications. The TComponent class in this context acts as a wrapper for a Component object that represents data in the iCalendar format.
In order to prevent confusion you can do the following:
open the EXICALENDARLib_TLB.pas file
rename all instances of "TComponent" to "TComponent_EXICalendar"
rename all instances of "AOwner: TComponent_ExICalendar" to "AOwner: TComponent; override"
The StrToDate is a method used to convert a date string to a TDateTime value. However, StrToDate relies on the system's ShortDateFormat to interpret the date format. If the format of the input string doesn't match the system's ShortDateFormat, a conversion error will occur. For instance, if you want to convert "5/24/2012" (interpreted as MM/DD/YYYY), and the system default is set to a different format (like DD/MM/YYYY), the method may incorrectly interpret or be unable to parse the date.
To handle this, you can temporarily modify ShortDateFormat to ensure StrToDate reads the date correctly. Here's a step-by-step guide with detailed code:
Save the Original Format: Before making any changes, save the current value of ShortDateFormat so it can be restored after the conversion
Set ShortDateFormat to Match the Input String: Modify ShortDateFormat to match the MM/DD/YYYY format of the input string ("5/24/2012")
Convert the String: Use StrToDate to convert the string to a TDateTime value
Restore the Original Format: After conversion, restore ShortDateFormat to its original value to avoid affecting other date operations in the application
The following example converts the string to a date and passes it to the Selection property of the Calendar object:
