Delphi | A simple mechanism for staking and claims | Cryptography library

There is RTLVersion111 constant which you can use to determine whether you are dealing with 11.1

Root cause of error:

Excel loses print area settings in non-English version of application when file is opened using automation.

Why this is happening:

When you define print area in a sheet, Excel internally creates a named range. It has two properties defining its name:

1. Name this property is always of the form WorksheetsName!Print_Area (if the sheet's name contains some special characters it is also enclosed in single quotes).
2. NameLocal has similar structure, but the second part is translated into the language of the application.

This is what it looks like when you open the file in Excel and inspect these properties in VBA, but when you open the same file using automation (for example using the code in question), then NameLocal is no longer translated. This bug causes the named range to not be recognized correctly as print area. oSheet.PageSetup.PrintArea returns an empty string.

Workaround:

Restore original print area after opening the file using:

oSheet.PageSetup.PrintArea:='Print_Area';

This line of code will throw an exception when there was no print area defined in sheet, so there are two options:

1. Place the line inside try..except block.
2. Iterate the Names collection and look for a Name ending with !Print_Area, for example:

What's the correct way in Delphi to check if a non-Suspended created TThread with FreeOnTerminate = True is still executing?

There is none.

As soon as self destroying thread is started, you are no longer allowed to touch reference holding such thread from outside code, because that reference can become stale at any time.

Under some circumstances (if logic handling OnTerminate call in DoTerminate is not modified in your custom thread class) you can safely access thread reference from OnTerminate event handler. However, that will not help you solve your problem because you cannot wait on self destroying thread. On Windows such code causes exception that can be caught and handled, but on other platforms it causes undefined behavior and random deadlocks. But even on Windows writing such code is not advisable.

If you need to check status of a thread, cancel it or wait for it, you cannot use self destroying threads. Period. (For those that may object previous statement, yes under some circumstances some of those things are possible, but they commonly lead to shooting yourself in the foot).

You can use following workflow with TWorkerThread, providing that you leave FreeOnTerminate on False in your thread constructor and construct unsuspended thread. All following methods must be called from the main thread to avoid race condition on Worker reference. Having one extra thread that does nothing while your form is open will not cause you any trouble.

DisplayAlerts is an undeclared variable.

Certain Application properties and methods can (effectively) have the Application omitted:

• ActiveCell, ActiveSheet, ActiveWorkbook, ActiveWindow, Addins, Charts, Selection, etc.
• Calculate, Evaluate, Intersect, Run, Union, etc.

(but see this answer why/how this works):

A boolean property such as DisplayAlerts (EnableEvents, ScreenUpdating, etc) doesn't fall into the above category.

A golden rule in order not to fall into such a trap is the usage of Option Explicit while writing macros.

This is the code that aligns some common controls... I don't know if it covers all the cases, but what I've tried so far has worked perfectly. It works in current Windows versions but God knows what will happen in future versions, when they will change the way controls are drawn.

There is no bug and Delphi returns proper value in PixelsPerInch.

PPI OS will return for the purpose of scaling your application is not the actual PPI value of the actual display device, but virtual pixel density.

For developing applications the PPI value you need is the one that OS gives you, not the actual PPI value of the display device.

Everything you need to know is baseline PPI for the OS and current PPI or the scale factor. Using those numbers you can then calculate number of scaled pixels from some baseline pixel value.

For instance, if your control baseline width is 100 pixels and screen scale is 150% from the baseline PPI then your runtime control size will be 150 pixels.

Different operating systems have different baseline PPI.

Calculation:

Both of these code snippets are wrong. You don't call Free on a variant. You call Free on an object instance. Simply remove that line.

As Remy pointed out: using the WinAPI you risk of being in some compatibility mode, resulting in getting a version reported that is lower than the actual.

1. One alternative is to check the file version of expected files, i.e.

   • %windir%\system32\ntoskrnl.exe or
   • %windir%\explorer.exe

   using GetFileVersionInfo() and VerQueryValue() - the HiWord(dwFileVersionLS) should be 22000 or higher (according to Windows NT build/release number).

2. Another is to look in the Registry under HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ at the text values CurrentBuild and CurrentBuildNumber, checking if the highest of both is 22000 or higher.

3. David already wrote a detailled answer in Checking Windows version on W10 with even more alternatives, although concentrating on the high/low version numbers, not the build. But WMI might help.

4. (This only works in retrospective with confirmed knowledge.) Check which API exports are available: the idea is that specific functions were introduced with specific Windows releases/versions, so if importing fails for one you know you're on a version below. An outdated example and an outdated list of minimum versions per function will give you an idea. Now you "only" have to find out which new functions are introduced with Windows 11.

Those are all not bulletproof, but you could combine them and then draw conclusions. And after all that you can still try your approach to parse texts instead of relying on numbers only. It also shows how easily you can manipulate your system into reporting different versions as per which method is used.

You need to get rid of the additional declarations of GetAll in ICatRepository and IDogRepository. If you just leave the GUID in these interfaces all works as expected.