Real Forms Controls Updated For Delphi 5 serial key or number

Real Forms Controls Updated For Delphi 5 serial key or number

Real Forms Controls Updated For Delphi 5 serial key or number

Real Forms Controls Updated For Delphi 5 serial key or number

Delphi (software)

For the macromolecular electrostatics modeling software package, see DelPhi.

Delphi is a technology that uses the Object Pascal programming language and an integrated development environment (IDE) for rapid application development of desktop, mobile, web, and console software,[3] currently developed and maintained by Embarcadero Technologies.

Delphi's compilers generate native code for Microsoft Windows, macOS, iOS, Android and Linux (x64).[4][5][6]

Delphi includes a code editor, a visual designer, an integrated debugger, a source code control component, and support for third-party plugins. The code editor features Code Insight (code completion), Error Insight (real-time error-checking), and refactoring. The visual forms designer has the option of using either the Visual Component Library (VCL) for pure Windows development or the FireMonkey (FMX) framework for cross-platform development. Database support is a key feature. Delphi is known for its fast compilation speed.

Delphi was originally developed by Borland as a rapid application development tool for Windows as the successor of Turbo Pascal. Delphi added full object-oriented programming to the existing language, and the language has grown to support generics, anonymous methods, closures, and native Component Object Model (COM) support.

Delphi and its C++ counterpart, C++Builder, are interoperable. They share many core components, notably the IDE, the VCL and FMX frameworks, and much of the runtime library. In addition, they can be used jointly in a project. For example, C++Builder 6 and later can combine source code from Delphi and C++ in one project, while packages compiled with C++Builder can be used from within Delphi. In 2007, the products were released jointly as RAD Studio, a shared host for Delphi and C++Builder, which can be purchased with either or both.


Delphi supports rapid application development (RAD). Prominent features are a visual designer and two application frameworks, VCL for Windows and FireMonkey (FMX) for cross-platform development.

Delphi uses the Pascal-based programming language Object Pascal introduced by Borland. It supports native cross-compilation.

To better support development for Microsoft Windows and interoperate with code developed with other software development tools, Delphi supports independent interfaces of Component Object Model (COM) with reference counted class implementations, and support for many third-party components. Interface implementations can be delegated to fields or properties of classes. Message handlers are implemented by tagging a method of a class with the integer constant of the message to handle.

Database connectivity is extensively supported through VCL database-aware and database access components.

Later versions have included upgraded and enhanced runtime library routines, some provided by the community group FastCode.


Delphi uses a strongly typedhigh-level programming language, intended to be easy to use and originally based on the earlier Object Pascal language. Pascal was originally developed as a general-purpose language "suitable for expressing the fundamental constructs known at the time in a concise and logical way", and "its implementation was to be efficient and competitive with existing FORTRAN compilers"[7] but without low-level programming facilities or access to hardware. Turbo Pascal and its descendants, including Delphi, support access to hardware and low-level programming, with the facility to incorporate code written in assembly language and other languages. Delphi's object orientation features only class- and interface-based polymorphism.[8] Metaclasses are first class objects. Objects are actually references to the objects (as in Java), which Delphi implicitly de-references, so there is usually no need to manually allocate memory for pointers to objects or use similar techniques that some other languages need. There are dedicated reference-counted string types, and also null-terminated strings.

Strings can be concatenated by using the '+' operator, rather than using functions. For dedicated string types Delphi handles memory management without programmer intervention. Since Borland Developer Studio 2006 there are functions to locate memory leaks.

Delphi includes an integrated IDE. The Delphi products all ship with a run-time library (RTL) and a Visual Component Library (VCL), including most of its source code. Third-party components (sometimes with full source code) and tools to enhance the IDE or for other Delphi related development tasks are available, some free of charge. The IDE includes a GUI for localization and translation of created programs that may be deployed to a translator; there are also third-party tools with more features for this purpose. The VCL framework maintains a high level of source compatibility between versions, which simplifies updating existing source code to a newer Delphi version. Third-party libraries typically need updates from the vendor but, if source code is supplied, recompilation with the newer version may be sufficient. The VCL was an early adopter of dependency injection or inversion of control; it uses a re-usable component model, extensible by the developer. With class helpers new functionality can be introduced to core RTL and VCL classes without changing the original source code of the RTL or VCL.

The compiler is optimizing and single pass. It can optionally compile to a single executable which does not require DLLs. Delphi can also generate standard DLLs, ActiveX DLLs, COM automation servers and Windows services.

The Delphi IDEs since Delphi 2005 increasingly support refactoring features such as method extraction and the possibility to create UML models from the source code or to modify the source through changes made in the model.

Delphi has communities on the web, where also its employees actively participate.

Backward compatibility[edit]

Although each new release of Delphi attempts to keep as much backwards compatibility as possible to allow existing code reuse, new features, new libraries, and improvements sometimes make newer releases less than 100% backwards compatible.

Since 2016, there have been new releases of Delphi every six months, with new platforms being added approximately every second release.[9]


Delphi offers two frameworks for visual application development, VCL and FireMonkey (FMX):

  • Visual Component Library (VCL) is the framework for developing pure Windows applications. VCL is a long-standing framework, included in the first release of Delphi and actively developed ever since then.
  • FireMonkey (later abbreviated FMX), was released in 2011, as part of Delphi XE2, together with an additional set of built-in compilers for non-Windows platforms. FireMonkey is a cross-platform framework for Windows, macOS, iOS, Android and Linux (x64). The GUI parts of FireMonkey are largely based on Direct3D and OpenGL. FireMonkey is not compatible with VCL; they are two separate frameworks. FireMonkey applications do, however, allow easy sharing of non-visual code units with VCL applications, enabling a lot of code to be ported or shared easily between the platforms.

Code examples[edit]

To show a message:

procedureTForm1.ShowAMessage;beginShowMessage('Hello World!');end;

To give a label a caption using the VCL:

procedureTForm1.ShowSomethingOnCreate;beginLabel1.Caption:='Hello World!';end;

To give a label text using FireMonkey:

procedureTForm1.ShowSomethingOnCreate;beginLabel1.Text:='Hello World!';end;


Delphi was originally one of many codenames of a pre-release development tool project at Borland. Borland developer Danny Thorpe suggested the Delphi codename in reference to the Oracle at Delphi. One of the design goals of the product was to provide database connectivity to programmers as a key feature and a popular database package at the time was Oracle database; hence, "If you want to talk to [the] Oracle, go to Delphi".

As development continued towards the first release, the Delphi codename gained popularity among the development team and beta testing group. However, the Borland marketing leadership preferred a functional product name over an iconic name and made preparations to release the product under the name "Borland AppBuilder".

Shortly before the release of the Borland product, Novell AppBuilder was released, leaving Borland in need of a new product name. After much debate and many market research surveys, the Delphi codename became the Delphi product name.[10]

The chief architect behind Delphi was Anders Hejlsberg, who had developed Turbo Pascal. He was persuaded to move to Microsoft in 1996.

On February 8, 2006 Borland announced that it was looking for a buyer for its IDE and database line of products, including Delphi, to concentrate on its ALM line. On November 14, 2006, instead of selling it, Borland transferred the development tools group to an independent wholly owned subsidiary company named CodeGear. Borland subsequently sold CodeGear to Embarcadero Technologies in 2008. Embarcadero retained the CodeGear division created by Borland to identify its tool and database offerings, but identified its own database tools under the DatabaseGear name. In 2015, Embarcadero was purchased by Idera Software, but the Embarcadero mark was retained for the developer tools division.

Early Borland years (1995–2003)[edit]

Delphi 6 trial version installation disc
Delphi 7 trial version installation disc
Borland Delphi

Delphi (later known as Delphi 1) was released in 1995 for the 16-bit Windows 3.1, and was an early example of what became known as Rapid Application Development (RAD) tools. Delphi evolved from Borland's "Turbo Pascal for Windows", itself an evolution with Windows support from Borland's Turbo Pascal and Borland Pascal with Objects, very fast 16-bit native-code MS-DOS compilers with their own sophisticated integrated development environment (IDE) and textual user interface toolkit for DOS (Turbo Vision). Early Turbo Pascal (for MS-DOS) was written in a dialect of the Pascal programming language; in later versions support for objects was added, and it was named Object Pascal. Delphi has always used Object Pascal, which continued to be developed, as its underlying object-oriented language.

Borland Delphi 2

Delphi 2, released in 1996, supported 32-bit Windows environments. Delphi 1 was bundled with it for creation of 16-bit Windows 3.1 applications. New Quickreport components replacing Borland ReportSmith.

Borland Delphi 3

Delphi 3, released in 1997, added new VCL components encapsulating the 4.71 version of Windows Common Controls (such as Rebar and Toolbar), TDataset architecture separated from BDE, DLL debugging, the code insight technology, component packages, component templates, DecisionCube and Teechart components for statistical graphing, WebBroker, ActiveForms, MIDAS three tier architecture, component packages and integration with COM through interfaces.

Inprise Delphi 4

Inprise Delphi 4 was released in 1998. IDE came with a completely overhauled editor and became dockable. VCL added support for ActionLists anchors and constraints. Additional improvements were method overloading, dynamic arrays, Windows 98 support, Java interoperability, high performance database drivers, CORBA development, and Microsoft BackOffice support. It was the last version shipped with Delphi 1 for 16 bit programming.

Borland Delphi 5

Borland Delphi 5 was released in 1999. Added concept of frames, parallel development, translation capabilities, enhanced integrated debugger, XML support, ADO database support and reference countinginterfaces

Borland Delphi 6

Attempts to support both Linux and Windows for cross-platform development were made, and a cross-platform alternative to the VCL known as CLX shipped in 2001 with the release of Delphi 6. This was the second product in Borland's series of Linux-compatible native developer tools, establishing code-compatible IDEs for both Linux (see Kylix above) and Windows (Delphi 6) using the shared CLX component framework for both. Later efforts would include CLX in C++Builder 6 and add C++ code-compatibility to the RAD tools line. Delphi 6 included the same CLX version (CLX 1) as the first version of Kylix. CLX 1 had been created before Delphi 6; its feature set was based on VCL 5 and lacked some features added to the VCL 6 shipped with Delphi 6.[11]

Borland Delphi 7

Delphi 7, released in August 2002, became the standard version used by more Delphi developers than any other single version. It is one of the most successful IDEs created by Borland because of its stability, speed and low hardware requirements, and remains in active use as of 2020. Delphi 7 added support for Windows XP Themes, and added more support for building Web applications. It was the last version of Delphi that did not require mandatory software activation.

Later Borland years (2003–2008)[edit]

Borland Delphi 8

Delphi 8 (Borland Developer Studio 2.0), released December 2003, was a .NET-only release that compiled Delphi Object Pascal code into .NET CIL; the IDE was rewritten for this purpose. The IDE changed to a docked interface (called Galileo) similar to Microsoft's Visual Studio.NET. Delphi 8 was highly criticized[by whom?] for its low quality and its inability to create native applications (Win32 API/x86 code). The inability to generate native applications is only applicable to this release; the capability would be restored in the next release.

Borland Delphi 2005

The next version, Delphi 2005 (Delphi 9, also Borland Developer Studio 3.0), included the Win32 and .NET development in a single IDE, reiterating Borland's commitment to Win32 developers. Delphi 2005 includes design-time manipulation of live data from a database. It also includes an improved IDE and added a for ... in statement (like C#'s foreach) to the language. However, it was widely criticized[12] for its bugs; both Delphi 8 and Delphi 2005 had stability problems when shipped, which were only partially resolved in service packs. The ability to compile native windows applications (*.exe) was added back into Delphi 2005 after being removed in Delphi 8. CLX support was dropped for new applications from this release onwards.

Borland Delphi 2006

In late 2005 Delphi 2006 (Delphi 10, also Borland Developer Studio 4.0) was released combining development of C# and Delphi.NET, Delphi Win32 and C++ (Preview when it was shipped but stabilized in Update 1) into a single IDE. It was much more stable than Delphi 8 or Delphi 2005 when shipped, and improved further with the release of two updates and several hotfixes.

Turbo Delphi and Turbo Delphi for .NET

On September 6, 2006 The Developer Tools Group (the working name of the not yet spun off company) of Borland Software Corporation released single-language editions of Borland Developer Studio 2006, bringing back the Turbo name. The Turbo product set included Turbo Delphi for Win32, Turbo Delphi for .NET, Turbo C++, and Turbo C#. There were two variants of each edition: Explorer, a free downloadable flavor, and a Professional flavor, priced at US$899 for new users and US$399 for upgrades, which opened access to thousands of third-party components. Unlike earlier Personal editions of Delphi, Explorer editions could be used for commercial development.

Codegear Delphi 2007

Delphi 2007 (Delphi 11), the first version by CodeGear, was released on March 16, 2007. The Win32 personality was released first, before the .NET personality of Delphi 2007 based on .NET Framework 2.0 was released as part of the CodeGear RAD Studio 2007 product. New features included support for MSBuild and enhancements to the VCL for Windows Vista, but the C#Builder feature was dropped in this release as sales were not as high as expected due to Visual Studio also offering C#. The Windows Form designer for Delphi .NET was also dropped in 2007 because it is based on part of the .NET framework API, which Microsoft had changed so drastically in .NET 2.0 that updating the IDE would have been a major undertaking. Delphi 2007 also introduced DBX4 as the next version of dbExpress. For the first time Delphi could be downloaded from the Internet and activated with a license key. Internationalized versions of Delphi 2007 shipped simultaneously in English, French, German and Japanese. RAD Studio 2007 (code named Highlander), which includes .NET and C++Builder development, was released on September 5, 2007.

Delphi for PHP

In CodeGear era emerged an IDE targeting PHP development despite the word "Delphi" in its name. That one is Delphi for PHP whose highlight is a VCL-like PHP framework which enables for PHP the same Rapid Application Development methodology as in ASP.NET Web Form. Version 1.0 and 2.0 were released in March 2007 and April 2008 respectively. The IDE would later evolve into RadPHP after CodeGear's acquisition by Embarcadero.

Embarcadero years (2008–2015)[edit]

Codegear Delphi 2009

Delphi 2009 (Delphi 12, code named Tiburón), added many new features such as completely reworking the VCL and RTL for full Unicode support, and added generics and anonymous methods for Win32 native development. Support for .NET development was dropped from the mainstream Delphi IDE starting with this version, and was catered for by the new Delphi Prism 2009 (Version 1.0).[13]

Delphi Prism was developed by RemObjects Software and distributed by Embarcadero from 2008 to replace Delphi.NET. It is a combination of RemObjects's mostly Delphi-compatible .NET compiler (without RTL or VCL), a version of the Microsoft Visual Studio Shell without C# or VB support, and some Embarcadero technologies such as dbExpress. Prism is cross-platform capable insofar as it supports the Mono .NET libraries.

Codegear Delphi 2010

Delphi 2010 (code-named Weaver, aka Delphi 14; there was no version 13), was released on August 25, 2009 and is the second Unicode release of Delphi. It includes a new compiler run-time type information (RTTI) system, support for Windows 7 Direct2D, touch screen and gestures, a source code formatter, debugger visualizers and the option to also have the old style component palette in the IDE. The new RTTI system makes larger executables than previous versions. Delphi Prism 2010 (Version 3.0) which is the last Visual Studio 2008 only based one was also released in August 2009.

Embarcadero Delphi XE

Delphi XE (aka Delphi 2011,[14] code named Fulcrum), was released on August 30, 2010 with Delphi support for Amazon EC2, Microsoft Azure were bundled. Delphi Prism XE (Version 4.0) which is the first Visual Studio 2010 based one (However, it can also integrated into Visual Studio 2008) was also released in August 2010. It is essentially a rebranded Delphi Prism 2011 (also Version 4.0) which was released three months earlier. RadPHP had been incorporated in to RAD Studio since RadPHP XE (Version 3.0) that was evolved from the formal Delphi for PHP product developed by CodeGear in its Borland days.

Delphi Starter Edition

On January 27, 2011 Embarcadero announced the availability of a new Starter Edition that gives independent developers, students and micro businesses a slightly reduced feature set[15] for a price less than a quarter of that of the next-cheapest version. This Starter edition is based upon Delphi XE with update 1.

Embarcadero Delphi XE2
RAD Studio XE2 World Tour

On September 1, 2011 Embarcadero released RAD Studio XE2 (code-named Pulsar,) which included Delphi XE2, C++Builder, Embarcadero Prism XE2 (Version 5.0 later upgraded to XE2.5 Version 5.1) which was rebranded from Delphi Prism and RadPHP XE2 (Version 4.0). Delphi XE2 natively supports 64-bit Windows (except the starter edition), in addition to the long-supported 32-bit versions, with some backwards compatibility. Applications for 64-bit platforms can be compiled, but not tested or run, on the 32-bit platform. The XE2 IDE cannot debug 64-bit programs on Windows 8 and above. Delphi XE2 is supplied with both the VCL, and an alternative library called FireMonkey that supports Windows, Mac OS X and the Apple iPhone, iPod Touch and iPad portable devices. FireMonkey and VCL are not compatible; one or the other must be used, and older VCL applications cannot use Firemonkey unless user interfaces are recreated with FireMonkey forms and controls. Third parties have published information on how to use Firemonkey forms in VCL software, to facilitate gradual migration, but even then VCL and Firemonkey controls cannot be used on the same form.[16] Embarcadero says that Linuxoperating system support "is being considered for the roadmap", as is Android, and that they are "committed to ... FireMonkey. ... expect regular and frequent updates to FireMonkey". Pre-2013 versions only supported iOS platform development with Xcode 4.2.1 and lower, OS X version 10.7 and lower, and iOS SDK 4.3 and earlier.

Embarcadero Delphi XE3

On September 4, 2012 Embarcadero released RAD Studio XE3, which included Delphi XE3, C++Builder, Embarcadero Prism XE3 (Version 5.2) and HTML5 Builder XE3 (Version 5.0) which was upgraded and rebranded from RadPHP. Delphi XE3 natively supports both 32-bit and 64-bit editions of Windows (including Windows 8), and provides support for Mac OS X with the Firemonkey 2/FM² framework. iOS support was dropped with XE3 release initially (with intent to add support back in with a separate product – Mobile Studio), but applications can continue to be targeted to that platform by developing with Delphi XE2.

Embarcadero Delphi XE4

On April 22, 2013 Embarcadero released RAD Studio XE4, which included Delphi XE4, and C++Builder. There has been no major upgrade for either Embarcadero Prism or HTML5 Builder thence. Delphi XE4 is the first release of the FireMonkey mobile platform, featuring cross-platform mobile application development for the iOS Simulator and iOS Devices. In this version Embarcadero introduces two new compilers for Delphi mobile applications, the Delphi Cross Compiler for the iOS Simulator and the Delphi Cross Compiler for the iOS Devices. These compilers significantly differ from the Win64 desktop compiler as they do not support COM, inline assembly of CPU instructions, and six older string types such as PChar. The new mobile compilers advance the notion of eliminating pointers. The new compilers require an explicit style of marshalling data to and from external APIs and libraries. Delphi XE4 Run-Time Library (RTL) is optimized for 0-based, read-only (immutable) Unicode strings, that cannot be indexed for the purpose of changing their individual characters. The RTL also adds status-bit based exception routines for ARM CPUs that do not generate exception interrupts.

Embarcadero Delphi XE5

On September 12, 2013 Embarcadero released RAD Studio XE5, which includes Delphi XE5 and C++Builder. It adds support for Android (specifically: ARM v7 devices running Gingerbread (2.3.3–2.3.7), Ice Cream Sandwich (4.0.3–4.0.4) and Jelly Bean (4.1.x, 4.2.x, 4.3.x)) and iOS 7.

Embarcadero Delphi XE6

On April 15, 2014 Embarcadero released RAD Studio XE6, which included Delphi XE6 and C++Builder. It allows developers to create natively compiled apps for all platforms for, desktop, mobile, and wearable devices like Google Glass, with a single C++ or Object Pascal (Delphi) codebase. RAD Studio XE6 adds support for Android 4.4 KitKat. It also became possible to create FireMonkey mobile apps for Android.

Embarcadero Delphi XE7

On September 2, 2014 Embarcadero released RAD Studio XE7, which included Delphi XE7 and C++Builder. It enables Delphi/Object Pascal and C++ developers to extend existing Windows applications and build apps that connect desktop and mobile devices with gadgets, cloud services, and enterprise data and APIs. Also, it enables developers to extend Windows applications using WiFi and Bluetooth App Tethering, and create shared user interface code across multiple device form factors, etc.

Embarcadero Delphi XE8

On April 7, 2015 Embarcadero released RAD Studio XE8, which included Delphi XE8 and C++Builder.

Embarcadero Delphi 10 Seattle

On August 31, 2015 Embarcadero released RAD Studio 10 Seattle, which included Delphi and C++Builder.

Idera years (2015–present), under the Embarcadero mark[edit]

Embarcadero Delphi 10.1 Berlin

On April 20, 2016 Embarcadero released RAD Studio 10.1 Berlin, which included Delphi and C++Builder, both generating native code for the 32- and 64-bit Windows platforms, OSX, iOS and Android (ARM, MIPS and X86 processors). Delphi 10.1 Berlin Update 2 introduced the ability to create Windows 10 Store applications from the Delphi IDE using Desktop Bridge.

Embarcadero Delphi 10.2 Tokyo

On March 22, 2017 Embarcadero released RAD Studio 10.2 Tokyo, adding 64-bit Linux support, limited to console and non-visual applications. In addition this release features RTL and IDE improvements, multi-tenancy support in RAD server and improved database capabilities.

Embarcadero Delphi 10.2 Tokyo (Community Edition)

On July 18, 2018 Embarcadero released Community Edition for free download. You are not allowed to earn more than $5,000. Library source code and VCL/FMX components are more limited compared to Professional.

Embarcadero Delphi 10.3 Rio

On November 21, 2018 Embarcadero released RAD Studio 10.3 Rio. This release had a lot of improvements, new components for High DPI / 4K screens on the VCL and an entirely new look for the IDE. Two new features were added to the language: inline block-local variable declarations and type inference. Versions 10.3.1, 10.3.2, and 10.3.3 (November 21, 2019) were also released.

Embarcadero Delphi 10.4 Sydney

On May 26, 2020 Embarcadero released RAD Studio 10.4 Sydney.

  • Windows Enhancements. High DPI UI elements on 4k monitors with styling support for visual controls. Integrate modern web technologies through Microsoft’s new WebView2 based on Chromium. Enhanced title bars.
  • Productivity. Faster and more reliable code completion in the IDE. Unified memory management on all platforms. Enhanced Visual LiveBindings
  • Other. Over 1,000 improvements. Custom managed records. Enhanced parallel tasks on multicore CPU. Metal API support on OS X and IOS. See full list of changes


Embarcadero publishes "roadmaps" describing their future development plans. The most recent one was published in May 2019,[17] which was amended in August 2019.[18]

Related software[edit]

  • Borland Enterprise Studio, a precursor to RAD Studio, is a software development suite that includes support for multiple languages. Borland Enterprise Studio for Windows supports Delphi.[19]
  • Borland Kylix: Similar to Delphi, but for Linux, released in 2001. This was the first attempt to add Linux support in the Delphi product family.[20] Kylix used the new CLX cross-platform framework, instead of Delphi's VCL. Kylix was discontinued after version 3.
  • RAD Studio: a development of tool suite by Borland Software Corporation (later Embarcadero), consists of Delphi, C++Builder, Embarcadero Prism, and HTML5 Builder. Like Delphi, there are different editions of RAD Studio: Professional edition, Enterprise edition, Ultimate edition and Architect edition.
  • InterBase integrates natively to Delphi and C++Builder for client/server or embedded development and can be accessed by all major languages and platforms in the market with database connection protocols like ODBC, ADO, ADO.NET and even with Java by JDBC/ODBC Bridge or Java type 4 connectors.
  • JBuilder is a tool for Java development based on Eclipse since version JBuilder 2007.
  • RadPHP (now superseded by HTML5 Builder) was an IDE for PHP that provides true RAD functionality. It has a form designer similar to that of Delphi or Visual Basic, and an integrated debugger based on the Apache web server. It also includes a VCL library ported to PHP. Unlike other IDEs it supports Web 2.0 features such as AJAX. Delphi for PHP was announced on March 20, 2007, renamed on October 2010 to RadPHP, and is based on Qadram Q studio. Embarcadero acquired Qadram in January 2011.
  • Delphi Prism (later known as Embarcadero Prism) derived from the Oxygene programming language (previously known as Chrome) from RemObjects. It ran in the Microsoft Visual Studio IDE rather than RAD Studio. It was licensed and re-branded by Embarcadero to replace Delphi.NET when that product was discontinued. Although RemObjects Oxygene was further developed and incorporated support for native Java, Android, iOS and OS X development, the version licensed by Embarcadero was limited to only supporting .NET. It was eventually discontinued by Embarcadero with the release of Delphi XE4, leaving the Delphi product line with no support for .NET development. The Oxygene product it was based on continues to be developed by RemObjects as part of their Elements product line.
  • Free Pascal is an open-source Pascal cross-platformcross-compiler that supports most of Delphi's Object Pascal code. Free Pascal also has its own language extensions, multiple compiler [language syntax] modes, and supports 18+ operating systems and 9+ processor architectures.[21]Lazarus is a cross-platform RAD IDE that uses the Free Pascal compiler. Lazarus and Free Pascal – free software independent of Embarcadero – are largely compatible with code written for Delphi.

Notable third-party libraries[edit]

  • FastCode – Enhanced runtime libraries and memory manager.
  • OpenWire (library) – Data flow, events, and state synchronization component library.
  • Project Jedi (Joint Endeavor of Delphi Innovators) – A collaborative open-source effort by the Delphi developer community to provide translations of Windows API interfaces, additional components and controls, and algorithms and data structures.
  • Teechart – Charting library.
  • Devexpress VCL Enhanced component library


Further reading[edit]

External links[edit]

Источник: []
, Real Forms Controls Updated For Delphi 5 serial key or number

3 easy steps to understand and control your RS232 devices

This article will explain the following topics in details:
1) Step 1: Understand RS232 Connection and Signals
2) Step 2: Learn about the Protocol
3) Step 3: Control your RS232 devices by using 232Analyzer

After reading this page, you should be able to understand most of the hardware and software (protocol) standards for RS232. If you have a chance to test your RS232 devices with the 232Analyzer software, you should be able to control your RS232 devices in a short period of time.

Step 1: Understand RS232 Connection & Signals

RS-232C, EIA RS-232, or simply RS-232, refers to the same standard defined by the Electronic Industries Association in 1969 for serial communication.


DTE stands for Data Terminal Equipment. A computer is a DTE. DCE stands for Data Communication Equipment. A modem is a DCE.

DTE normally comes with a Male Connector, while DCE comes with a Female Connector. However, that is not always true. Use the simple way below to confirm: Measure Pin 3 and Pin 5 of a DB-9 Connector with a Volt Meter, if you get a voltage of -3V to -15V, then it is a DTE device. If the voltage is on Pin 2, then it is a DCE device.

Note: The result for a DB-25 Connector is reversed (Please refer to DB-9 to DB-25 conversion table below).

RS-232 Pin outs (DB-9)

A male DB-9 connector viewed from the front. Reverse or back view of male connector for Female Connector.

DTE Pin Assignment (DB-9)DCE Pin Assignment (DB-9)
1DCDData Carrier Detect1DCDData Carrier Detect
2RxDReceive Data2TxDTransmit Data
3TxDTransmit Data3RxDReceive Data
4DTRData Terminal Ready4DSRData Set Ready
5GNDGround (Signal)5GNDGround (Signal)
6DSRData Set Ready6DTRData Terminal Ready
7RTSRequest to Send7CTSClear to Send
8CTSClear to Send8RTSRequest to Send
9RIRing Indicator9RIRing Indicator

DB-9 to DB-25 Conversion

DB-9 DB-25Function
18DCDData Carrier Detect
23RxDReceive Data
32TxDTransmit Data
420DTRData Terminal Ready
57GNDGround (Signal)
66DSRData Set Ready
74RTSRequest to Send
85CTSClear to Send
922RIRing Indicator

RS-232 Connections

A straight-through cable is used to connect a DTE (e.g. computer) to a DCE (e.g. modem), all signals in one side connected to the corresponding signals in the other side in a one-to-one basis. A crossover (null-modem) cable is used to connect two DTE directly, without a modem in between. They cross transmit and receive data signals between the two sides and there are many variations on how the other control signals are wired, below is one of them:

Straight-through (DB-9)Crossover (Null-Modem) (DB-9)

RS-232 Signals

The graphic above illustrates a typical RS-232 logic waveform (Data format: 1 Start bit, 8 Data bits, No Parity, 1 Stop bit). The data transmission starts with a Start bit, followed by the data bits (LSB sent first and MSB sent last), and ends with a "Stop" bit.

The voltage of Logic "1" (Mark) is between -3VDC to -15VDC, while the Logic "0" (Space) is between +3VDC to +15VDC.

RS-232 connects the Ground of 2 different devices together, which is the so-called "Unbalanced" connection. An unbalanced connection is more susceptible to noise, and has a distance limitation of 50 ft (which is around 15 meters).

Step 2: Learn about the Protocol

A protocol is one or a few sets of hardware and software rules agreed to by all communication parties for exchanging data correctly and efficiently.

Synchronous and Asynchronous Communications

Synchronous Communication requires the sender and receiver to share the same clock. The sender provides a timing signal to the receiver so that the receiver knows when to "read" the data. Synchronous Communication generally has higher data rates and greater error-checking capability. A printer is a form of Synchronous Communication.

Asynchronous Communication has no timing signal or clock. Instead, it inserts Start / Stop bits into each byte of data to "synchronize" the communication. As it uses less wires for communication (no clock signals), Asynchronous Communication is simpler and more cost-effective. RS-232 / RS-485 / RS-422 / TTL are the forms of Asynchronous Communications.

Drilling Down: Bits and Bytes

Internal computer communications consists of digital electronics, represented by only two conditions: ON or OFF. We represent these with two numbers: 0 and 1, which in the binary system is termed a Bit.

A Byte consists of 8 bits, which represents decimal number 0 to 255, or Hexadecimal number 0 to FF. As described above, a byte is the basic unit of Asynchronous communications.

Baud rate, Data bits, Parity, and Stop bit

The baud rate is the communication speed that measures the number of bit transfers per second. For example, 19200 baud is 19200 bits per second.

Data bits are a measurement of the actual data bits in a communication packet. For example, the above graphic shows eight (8) data bits in a communication packet. A communication packet refers to a single byte transfer, including Start / Stop bits, Data bits and Parity. If you are transferring a standard ASCII code (0 to 127), 7 data bits are enough. If it is an extended ASCII code (128 to 255), then 8 data bits are required.

Parity is a simple way to error-check. There are Even, Odd, Mark and Space indicators. You can also use no parity. For Even and Odd parity, the serial port sets the parity bit (the last bit after the data bit) to a value to ensure that the data packet has an Even or Odd number of logic-high bits. For example, if the data is 10010010, for Even parity, the serial port sets the parity bit as 1 to keep the number of logic-high bits Even. For Odd parity, the parity bit is 0 so that the number of logic-high bits is Odd. Mark parity simply sets the parity bit to logic-high and Space sets the parity bit to logic-low, so that the receiving party can determine if the data is corrupted.

Stop bits are used to signal the end of a communication packet. This also helps to synchronize different clocks on the serial devices.

Handshaking (Flow Control)

Handshaking is also called "Flow Control". The main purpose of Handshaking is to prevent receiver overloading. By using Handshaking signals, receivers will be able to tell the sending device to pause data transmission if the receiver is overloaded. There are three types of handshaking: Software handshaking, Hardware handshaking and Both.

Software handshaking uses two control characters: XON and XOFF. The receiver sends these control characters to pause transmitter during communication. XON is decimal 17 and XOFF is decimal 19 in the ASCII chart. The drawback of Software handshaking is that these two control characters can not be used in data. This is quite important when you are transmitting Binary data as you might need to use these two codes in your data.

Hardware handshaking makes use of actual hardware lines, such as RTS / CTS, DTR / DSR, and DCD / RI (for modem).

In DTE / DCE communication, RTS (Request to Send) is an output on the DTE and input on the DCE. CTS (Clear to Send) is the answering signal coming from the DCE. Before sending a data, the DTE asks permission by setting its RTS output to high. No data will be sent until the DCE grants permission by using the CTS line. The DTE uses the DTR (Data Terminal Ready) signal to indicate it is ready to accept information, whereas the DCE uses the DSR signal for the same purpose. DTR/DSR are normally ON or OFF for the whole connection session (e.g. Off-hook), while RTS/CTS are ON or OFF for each data transmission. DCD (Data Carrier Ready) is used by the modem when a connection has been established with remote equipment, while RI (Ring Indicator) is used by the modem to indicate a ring signal from telephone line.

Data formats (Binary, Hex, Dec, Oct, and ASCII)

Serial devices use Binary for communication, which consists of just two unique numbers: 0 and 1.

Binary is the Base-2 numbering system. One byte of data consists of 8 binary digits, from 0000 0000 to 1111 1111. Hexadecimal is the base-16 system, which consists of 16 numbers: 0 to 9 and the letters A to F (decimal number 15).

The Hexadecimal numbering system is useful because it can represent every byte as two consecutive hexadecimal digits, and it is easier for humans to read Hexadecimal numbers than Binary numbers. Most of the manufacturers use Hexadecimal in their protocol documentation. It is simple to convert a value from Hexadecimal to Binary. Just translate each Hexadecimal digit into its 4-bit binary equivalent. E.g. Hexadecimal number F3 equals Binary number 1111 0011.

Decimal refers to numbers in base 10, which is the numbering system we use most in everyday life. It's not as easy as Hexadecimal and Octal to converter Decimal to Binary number, but it is easier for us to understand Decimal.

Octal refers to the base-8 numbering system, which uses just eight unique symbols (0 to 7). Programmers often use Octal format because it is relatively easy for people to read and can easily be translated into binary format: each Octal digit represents 3 binary digits. E.g. Octal number 73 equals to Binary number 111 011.

ASCII (American Standard Code for Information Interchange) is a character encoding based on the English alphabet. ASCII codes (both readable and unreadable) are widely used in communications, such as Modem communications. Letters A to Z and numbers 0 to 9 are readable ASCII codes. Some ASCII codes are unreadable, such as the control codes: XON and XOFF, which are used in Software flow control.


Many serial protocols use checksum (additional bytes added at the end of the data string) to check the data integrity, as errors might occur during data transmission. There are many types of checksum, from the simplest uses of it in Modula or BCC to sophisticated CRC calculation. Using Modula as an example, we learn that before data transmission, the sender adds all command bytes together then mod it by 255 (decimal) to get an additional byte. This is to be added at the end of the command string. When the receiver receives the command string, it will first check the added byte to see whether data remain unchanged or not. If that is the case, it will accept the data, and if not, it will ask the sender to resend the data.

Examples of protocol commands

A protocol command is a data string sent from one serial device (e.g. a Computer) to another (i.e. a Modem). Here are some examples:

ASCII command example: ATI1

Convert the command string above to Hexadecimal and it becomes: 41 54 49 31 0D 0A

Convert the command string above to Decimal and it becomes: 065 084 073 049 013 010

Convert the command string above to Octal and it becomes: 101 124 111 061 015 012

Convert the command string above to Binary and it becomes: 01000001 01010100 01001001 00110001 00001101 00001010

Step 3: Control your RS232 devices by using 232Analyzer

232Analyzer is an Advanced Serial Port Protocol Analyzer software, which allows you to control / debug, monitor / sniff serial devices (RS-232 / RS-485 / RS-422 / TTL) right from your PC. 232Analyzer is a shareware, the FREE version has some limitation but is more than enough to test and control your serial devices. Click here to download a FREE copy.

Checksum calculation

232Analyzer comes with a Checksum calculator, which allows you to calculate the complicated checksum byte in seconds, here is an example:

Suppose that you are controlling a projector, and the projector protocol uses xOR to get the additional checksum byte, the command string to turn ON the projector is: "1A 2B 3C" plus the Checksum byte. Use the following procedures to calculate the Checksum byte:

  1. Select Hex as an operands format
  2. Select xOr as an operator
  3. Key in the command string and append a comma (,) after each byte of command code: e.g. 1A,2B,3C,
  4. Click on the "Calculate" button and you will get the result of 0D (0 is omitted)

Select COM port and Setup communication formats

From the above toolbar example, the COM port connected to the projector has been set as: COM port: 5, Baud Rate: 19,200 bps, Data bit: 8, Parity: Even, Stop bit: 1.

Note: After you have set up the correct communication formats (they must match with the projector's COM port settings), click on the "Connect" button on the left to activate the COM port.

Flow control settings

Flow control can be set from the window above. Either Software (XON / XOFF), Hardware (RTS / CTS), Both (Software + Hardware), or None can be selected.

Control your RS232 devices

  1. Control / Monitor Line States

    232Analyzer allows you to control / monitor line states of your COM ports.

    1. Line states of RTS and DTR will be toggled when the respective LED is clicked, you can use a voltage-meter to verify the changes, you should get +6V to +15V when the line state is ON, and -6V to -15V when the line state is OFF.
    2. Other line states can be monitored through the Virtual Ds, such as RX, TX, DSR, CTS, DCD and RI.
  2. Send / Receive commands

    Use the above example to control a projector (turn ON the projector), key in the complete command string "1A,2B,3C,0D," into the Send_Command_Pane as shown above, and then click on the "Send" button...


    1. In the FREE version, Hex mode is not available. You can use Decimal format to send out the command string: "26,43,60,13,"
    2. You can use any RS-232 device for testing, as long as you know the protocol commands.
Источник: []
Real Forms Controls Updated For Delphi 5 serial key or number

Migrating your project from older versions of Delphi. The Pitfalls.

A true testament to Delphi is the number of applications out in the wild which were written with much older versions. Every day, I am asked questions about migration from versions as old as 15-20 years, to the latest edition. Thankfully, Delphi makes migration over the decades relatively painless, however, this doesn’t mean effortless!

This page aims to address the most common pitfalls which may befall a migration from any version of Delphi prior to 2009, including Borland versions, to modern Embarcadero versions.

I intend this page to become something of a living document, which I will update over time to include any pitfalls that I uncover. I will also aim to add tips & tricks for the migration process, and links to relevant documentation.
If you come across something which is not included, please register and leave a comment, which I may integrate into this page.

Expectations of Cross Platform.

Before we begin looking at the common pitfalls of a version migration, I would like to take a moment, (actually, a good page or two,) to discuss an often miss-understood feature of modern Delphi versions. If you have no interest in migrating your code to mobile platforms, or the MAC desktop, go ahead and skip to the section entitled “Windows 64-bit migration” and we’ll pick up from there.

Modern Delphi is able to compile code to target Windows 32-bit and 64-bit, MAC OSX, Android and iOS. This fact has lead to an expectation that Delphi can take your Windows application and somehow, make it cross platform. This is not true! It would be some genuine kind of magic if it were true, but it isn’t. What is true is this: Modern versions of Delphi make it possible to write applications for Windows, Mac OSX, Android and iOS.

If your application was originally written for Windows then it uses the Win32 API. If your application is a VCL application, then it uses the Win32 API. One thing that is not available on Mac OSX, Android, and iOS is the Win32 API. See where I’m going? Your application is not going to run on another platform without some significant changes. Thankfully, while Delphi won’t magically fix this problem for you, there are some companion tools to help…

Cross platform applications are written against a new framework named FMX. (Formerly FireMonkey, FMX=FireMonkey X-platform).
The FMX framework does not depend on the Win32 API and it’s controls, but instead, actually opens up a rendering context using OpenGL or DirectX, and renders controls directly to that API. In this way, visual controls become cross platform. The FMX framework has mirror controls for the vast majority of VCL controls which ship with Delphi, for example, VCL and FMX both have a TEdit control, they both have a TButton control, and so on..

There is a tool called the ‘Mida converter’ ( see here ) which is able to open up your existing VCL forms (the .dfm files) and modify them to use the FMX versions of controls instead of the VCL controls. In doing so, the form is effectively ported from VCL to FMX and therefore is made available to platforms other than Windows. There are still one or two pitfalls to this approach however. The Mida converter is not much more than a copy/replace macro tool, if you are using controls which are not a part of the VCL (third party controls for example), then the Mida converter cannot migrate these controls, you’ll have to track down an FMX version of that control if it exists, or an FMX replacement from another third party vendor.

One such vendor of FMX components is TMS Software:

Further Cross Platform Considerations

Beyond the visual controls, there are several other considerations when moving from a Windows-Only application to a cross platform solution. For a start, all of the platforms supported by Delphi, other than Windows, are in some way based on a unix/linux variant, and are therefore POSIX based. Some things to consider because of this…

  • POSIX platforms have different file systems. There is no ‘C:’ drive on an Android, iOS or MAC device. If you’ve hard-coded windows paths into your application, then you’re going to have to modify the code, likely using conditional defines, to understand where the same file lies on the other platforms file systems.
  • There is no registry. Though some platforms offer a simulation of the windows registry, the majority of them have no such thing. Instead, configuration is usually stored in a specific directory. The ‘/etc’ directory is most commonly used to store configuration files, and, there’s no pre-specified file format. One application might use a .ini file or similar name-value pairs file, while another may use a JSON file, and yet another might use an XML file. If your VCL application depends on configuration in the registry, you’re going to have to migrate it to a file under the configuration directory for other platforms. If your VCL application modifies the behavior of the OS or other applications through alteration of registry keys, you’re going to have to find out how the same functionality can be achieved on other platforms.
  • There is no Kernel32. If you’re using custom calls to the windows API’s, you’ll have to find the equivalent behavior of the alternate platforms. In many cases the FMX classes will provide an answer, but if your application is VCL it’s likely not using those classes.
  • Not all TCanvases are made equal. If your code, or that of a third party vendor, is making direct calls to TCanvas for rendering, or worse, directly to the GDI, you’ll need to migrate this code to work on other platforms. The FMX framework has a TCanvas just as VCL does, however, the methods are not all the same, they also have different parameter lists. This is unavoidable as the VCL TCanvas was rendering to the windows GDI interface, where-as, the FMX TCanvas is rendering using a 3D API such as OpenGL or DirectX. This is true even for 2D rendering, because modern graphics cards simply don’t offer 2D rendering anymore, instead, they expect you to render 2D graphics into 3D space, and then view them with a special perspective mode which reduces out the Z-Axis. Sorry, you’ll have to migrate the TCanvas code too.
    More on: Using the FMX TCanvas
  • Your database driver probably doesn’t exist. Many developers are familiar with using components named TConnection, TTable, and TQuery (or similarly named equivalents) to connect to databases directly. These component sets usually rely on some binary driver, and unfortunately, unless you’re using InterBase, there probably isn’t a version of that driver available for the ARM-*nix based mobile platforms that you’re targeting. You likely cannot connect your application directly to a database, and even if you could, you may not want to with potentially unstable internet connectivity in many mobile scenarios. The most common solution to this problem is to expose your data in the form of JSON using a REST based web service (with SOAP services making up the second most common solution). Delphi has several components for working with JSON/REST/SOAP and can even adapt a JSON service into a TQuery style component for you, but you’ll have to migrate away from your older data access components.
  • There are some differences in the mobile compilers. Delphi achieves it’s single source code, multiple target platforms functionality by the use of multiple compilers. One compiler for windows 32, another for windows 64, an more still for android, iOS and Mac. Well, not all of these compilers are 100% compatible, though they are a good 99.9%.
    • ARC. The mobile compilers use the ARC (Automatic Reference Counting) memory model, so your code needs to be made ‘ARC safe’, this can be done in such a way that you do not damage the code for desktop platforms, however, you need to be aware of ARC and how it works to ensure that your code is safe for it. Not doing this will lead to bugs which can be quite difficult to track.
      Marco Cantu on ARC:
    • No Ansi Strings. The mobile compilers do not support ansi strings at all, period. Functions such as StrAlloc(), StrDispose() etc are missing, and if you absolutely must use ansi strings, well then you’ll have to put them into arrays or buffers and work with them using pointers – but you should probably just give up on ansi-strings, no modern OS or modern software uses them anymore! Unicode migration may instill some fear, but it’s not too frightening, and it is worth-while, as we’ll see later in this page.
    • Strings index from zero! All otherarray style access is indexed from zero, but for some reason, legacy pascal indexed characters in a string from one. If I ever did know why this was, I’ve long since forgotten, but it’s no longer true for the mobile compilers. Strings now index from zero. This is, sadly, just something we have to swallow. We got away with strings being the odd-one out for a long time, but it’s time to put this long standing syntactical faux-par to rest.

A Final word, and some hope, on Cross Platform migration.

Most developers with the mistaken expectation that Delphi will migrate their application to other platforms for them, are also missing one key important detail, in that they probably don’t actually want to migrate their application to those platforms at all! If you’re among them, stay with me here. Mobile screens are small, and operated with a cumbersome finger rather than the elegant precision of a mouse. Mobile devices also suffer a lack of resources (RAM, Disk Space, CPU cycles etc) when compared to desktops. It’s quite possible that if you did a straight migration of your VCL application to FMX and deployed that to a mobile device, it would be unusable on such a small screen, or perform horribly due to the lack of device resources.

A far more sensible strategy, in many cases, is to consider starting an entirely new project for your mobile application. This “companion app” project can still make use of large portions of your non-visual code, it’s still pascal after-all, but you can limit the new project to only those features which actually make sense on the mobile device. What’s more, Delphi ships with some classes to aid integration of your mobile companion application, into a network along-side your existing desktop application. For example, with the app-tethering classes, your mobile application can directly call actions within your desktop application, and bidirectionally share data.

Windows 64-bit migration.

Migration from Windows 32-bit to Windows 64-bit is a far less treacherous endeavor than migration to entirely different platforms, however, there is one pitfall that I’ve come across in doing so.

It became quite a common practice in the Delphi developer community, to assume that an integer and a pointer are the same size (32-bits), and given that instances of classes in Delphi are actually just a special kind of pointer, you could effectively type-cast a class as an integer for storing in an integer array. In addition to this, the .TAG property on may visual classes of the VCL was also a 32-bit integer and may have been used as an object pointer by some type-casting jiggery-pokery. Well, if you’ve done this, or you’re compiling third party sources which do this, you’ve now got a problem. Under windows 64-bit, pointers are, of course, 64-bits wide, however the integer type remains 32-bits wide. You need to alter this code to account for the different data types.  Some new integer data types have been added to assist. NativeInt and NativeUInt are new datatypes which act as an integer, but which will always match the width of a pointer on the target platform.

Now before you run off and start fixing up your code for 64-bits, ask yourself if you really need to? There are many common misconceptions about 64-bit code, and often there is little benefit in upgrading to it. We’re not in the same situation as were were when computers moved from the 8-bit era to 16-bit, or from 16-bit to 32-bit.

You see, one of the most common reasons to upgrade an application to 64-bits is to give the application more addressable memory space. With 8-bits you can only address 256 bytes of RAM, and to enable for more, certain bank switching operations were required which cost processing time. Things improved with 16-bits, you could address a whopping 64k of RAM, and still bank switching was required to make use of more memory. Enter 32-bit modes and you can address a giant 4GB of RAM! Even today, this is sufficient for the vast majority of applications, and Windows 32-bit would only really ever allow your application to use 2GB of it in any case, reserving the other 2GB for kernel space.

With some few exceptions, if your application is using more than 2GB of RAM, you’re probably doing something wrong.
For example, if you’re dragging back millions of rows of data from a database, do you really need it all held in RAM? For display purposes, no human wants to see those millions of rows all at once, even if you could cram them all on the screen, so perhaps caching to disk file is a better strategy. Essentially, the vast majority of applications will operate with 2GB-4GB of addressable RAM, so this may not be a reason to upgrade.

What about speed? Well, 64-bit processors aren’t really any faster than their 32-bit counterparts, their speed advantages come from being able to handle wider integers. So if your application needs to work with very large numbers, an upgrade to 64-bit might improve performance, but, if your code doesn’t already use 64-bit numerical data types, you’ll have to go through all of your code and replace the 32-bit types with 64-bit equivalents. Recompiling the same application for a 64-bit target won’t cut it.

Ultimately, there might be no good reason to upgrade at all, and remember, 64-bit executable files are significantly larger than 32-bits, because all of the instruction operands and encoding is larger. Be sure you need 64-bits before making the jump.

Unicode Migration.

The dreaded unicode migration, which somehow seems to fill so many developers with fear! Unicode is not so scary as it might sound, in fact, of all the compiler products that have migrated into the unicode era, Delphi is one of the easiest. Some projects will require zero changes, the compiler simply takes care of it for you, while other projects, well they may require some changes, and a few projects will require a lot of changes.

There is a tool ( Unicode statistics tool ) which can help you to determine the number of changes that you’ll need to make. You point this tool at your project and unit files, and it’ll perform a statistical analysis of the code for you, and give you some measure of the effort required.

In most cases the compiler will gracefully coerce the string types so that your code continues to compile and function as expected. The cases in which this is not true typically include the following scenarios:

  • Using strings to store binary. To some this may seem like a crazy idea, but very early versions of Delphi had a limitation on the storage of binary data (no array of byte), which caused creative Delphi engineers to take this option of using a string to store binary data. This type of code should have long since been replaced, I mean, you have had two decades to fix it! You may however still be using code which does this, and you’ll now be forced to correct it because the compiler has no idea what you’re doing. There’s just no way for the compiler to determine that you’re misusing the string data type, and so it can’t help you here.
  • Serialization and Deserialization. If your application has serialized strings (i.e. passed them byte-by-byte into a stream) for storage on disk or in a database, well, those strings were ANSI when the serialization took place. After you migrate your code to newer Delphi compilers, the application will attempt to deserialize the string from the file as a UTF16-LE unicode string, in which each character is 16-bits wide (save some which are 32-bits, but that’s a complication worthy of more reading on unicode). So your old serialized data cannot be deserialzed. One solution would be to read that string as a byte-array, and pass the byte array to one of the many unicode conversion routines which are now a part of the RTL, in order to convert it from an ANSI string to a UTF16LE string.
  • Calls to older APIs. Windows went unicode a long time ago. When the Win32 API was upgraded, new versions of each API call were put in place with a ‘W’ post-fix, indicating that they are wide string versions of the calls. Wide strings are a specialized string type used by windows, but the data contained within them is essentially UTF16-LE, the same type of data as is now the Delphi default string type. Anyway, the compiler may complain to you if you’re passing a string (now UTF16) to an older ANSI based API call. In most cases the compiler will also take care of the conversion for you, but a warning will be generated so that you know this has happened, and you’ll perhaps need to type-cast a parameter or two. This would get you working again, but ideally, you should migrate to the Unicode form of your API if it’s available.
  • Some controls behave differently under unicode!
    As you are likely already aware, most VCL controls are wrappers around the controls provided by the windows API. During migration of the VCL to unicode, many ANSI API calls were replaced by calls to their alternate unicode aware equivalents. I recently discovered a discrepancy in the way that the ‘SelStart’ and ‘SelLength’ properties of the TRichEdit component function. Carriage returns aren’t counted in these properties now, as they were in pre-unicode versions. I’ve added a blog post with some solutions to these problems here: 

More details on unicode migration with Delphi (far more detail than is covered here) may be found here at

The real datatype.

Often neglected in discussions of version migration is that the old ‘real’ datatype has been removed from the compiler, and replaced as an alias to the ‘double’ datatype. The reason it’s often neglected is that it’s so very rarely a problem, however, just as with the unicode migration, this little change can raise it’s head when deserializing data which was serialized with an application compiled with an earlier Delphi version. Head’s up if you use reals in your code.

The BDE is gone!

Don’t panic. The BDE is not actually completely gone yet, but it is being deprecated. By default, the BDE no longer ships with Delphi but may be downloaded separately from your EDN account after you make your Delphi purchase. The reason for this is that the BDE is very old, is lacking in unicode support, and has been replaced by the far superior FireDAC.

If your application makes use of the BDE, it is recommended that you use the reFind tool to migrate the project over to FireDAC. ( Migration from BDE to FireDAC using reFind / David I on Migration to FireDAC and Interbase ) This tool pretty much does the work for you! I haven’t heard of anyone actually having difficulties with this, and so if you have had difficulties and especially if you’ve found solutions, consider registering and leaving a note in the comments!

Still using paradox?

Some older applications are still using the paradox database. Unfortunately this database is no longer supported and so you’re likely going to have to migrate to another database engine. If you’ve only ever used paradox for your database needs, you’ll likely want to learn a little SQL and DDL too, in order to take advantage of more modern databases. Such tuition is beyond the scope of this page, but you’ll find some excellent tutorials online and it’s going to be worth your while, honest!

Marco Cantu on migrating from Paradox and dBase.
W3Schools SQL Tutorial.

Third party components.

I’ve saved the best until last for you! Some developers love them, others hate them, but in both schools you’re probably using at least some third party components. The two biggest reasons for dislike of third party components are:

  • Issues with the vendor. They may be unreliable at providing updates, bug fixes etc, or may have gone away entirely.
  • Issues with the components. Components which are poorly written can affect the stability of your application and even the Rad Studio IDE.

If you chose your vendor carefully however, you’ll have found an excellent third party component set, with frequent maintenance, and which provides stable high quality components which radically enhance Rad Studio / Delphi, and in turn your product too. For this reason, I fall into the love ’em category!

Regardless of where you fall on this, if you’ve used third party components, you’ll need up-to-date versions of them before you can migrate your project from an older Delphi version to a new one. Embarcadero are making efforts to aid in this with their new GetIt feature, which provides a third party component repository to automatically install several popular component sets right within the IDE!

See: RadStudio XE8 gets a component repository!

The collection of components in this repository is small, but growing, and Embarcadero have even funded updates to common component sets who’s maintainers had gone away or abandoned their products. Embarcadero also assures that components in the repository will be kept up-to-date with the latest Delphi versions, so can’t find yourself in the position of not having that component set again in the future.

At the time of writing this, the components installed in the GetIt repository include:

Abbrevia 10.0
AerServ 10.0
AsyncPro for VCL 1.0
Boos 1.39 / 1.55
Essentials TurboPack for VCL 1.0
ICS forFMX and VCL 8.16
Lockbox 2.0
Lockbox 3.5
Modernized AggPas VCL
OmniThread library 3.04a
OnGuard for FMX 1.0
OnGuard for VCL 1.0
Orpheus for VCL 4.0.8
PowerPFD for VCL 1.0
SynEdit 1.0
SysTools for VCL 4.04
VirtualTree for VCL 5.5

If you’re not yet using XE8, several of these components are also available for XE7 from here: Romans Blog

If you’re in the unfortunate position that you have third party components which are no longer maintained, but you were wise enough to purchase the source code, it’s often relatively trivial to update that code to compile in the latest version of Delphi. I recently posted an update to the Advantage database components for example, because SAP had not yet upgraded them for Delphi XE8. The only real change that I had to make in the code was to alter a conditional define to include the current compiler version number, and that’s it!

Also, if you used to use components found on source forge, but which appear to have fallen out of maintenance, be sure to go check at GitHub to see if the project was migrated. Lots of them were, without warning or update.

Finally, if you have third party components which are no longer maintained, and for which you do not have source code, well then I’m sorry but you’re out of luck. Over the decades, companies have entered and left the Delphi community and there was no avoiding that. If you wish to upgrade you’re going to have to find equivalent components from another vendor, and modify your code to suite those.

How long will my migration take?

It’ll take approximately twice as long as half the task. I’m sorry, but project to project things will vary wildly. You may not touch any of the above migration pitfalls, or you might be unfortunate enough to hit all of them.

Some of my C++ customers have reported an average of one day to convert a legacy C++ Builder project with 60,000 lines of code. While C++ Builder is it’s own product in it’s own right, it too is VCL and FMX based and went through the unicode migration, and so these numbers may be a vague guide. Be sure to use the Unicode migration statistics tool linked above, and be conservative but not fearful of migration.


If this looks like a lengthy page already, keep in mind that I’ve touched upon cross platform migration which I could have left out, and we’re discussing migration over two decades of versions in Delphi. Version to version, Delphi breaks very little, but it’s a mature product that has had to change with the times.

Modern Delphi has a great many features in an IDE which is (at least in my opinion,) second to none. It has all the modern language features you’d expect and is able to stand it’s ground in the desktop, n-tier enterprise, cloud and mobile development spaces. If you’re not using the latest version, you are missing out on a lot! I hope your migration progresses well.

Thanks for reading!

Источник: []

What’s New in the Real Forms Controls Updated For Delphi 5 serial key or number?

Screen Shot

System Requirements for Real Forms Controls Updated For Delphi 5 serial key or number

Add a Comment

Your email address will not be published. Required fields are marked *