csdesign | Simple examples of concurrent server design in Python

You should not be calling your LoadFromState procedure either from TBaseForm.FormShow or TBaseForm.FormActivate.

TBaseForm.FormShow is called every time visibility of your form changes from False to True.
So for instance if you hide your from when showing another and then show it again after another form is closed TBaseForm.FormShow will fire and thus you will load form's dimensions and position from the saved state which might not be the same state as of when the form was hidden. User might have moved and resized the from since application was started.
This will lead to form moving its position without users wish to do so and thus it will annoy your users as hell.

Also don't use TBaseForm.FormActivate as this fires every time Form receives focus. So changing focus from another back to this one will the TBaseForm.FormActivate and thus change your form dimensions and position to the saved state which might not be teh state when form lost its focus.

The correct place for you to call your LoadFormState procedure with which you load initial properties of your form is within the forms constructor.

The condition would render False.

That means for you as component builder that when you apparently intentionally create a (sub-)component without an owner, any reliance on whether that component is being designed by an end user simply should not exist. If it does, you would have to implement a custom "is designing"-state system, but then you better should redesign your requirements.

For overriden components you could call the protected SetDesigning method yourself.

This all assumes that you are fully aware of creating designtime sub-components without owner generally should be prevented unless you have very compelling reasons not to. Remember that components on the component pallete always should follow the default owner-mechanism.

After the help of comments above (mainly of @Remy Lebeau) follows this code working. I hope that can help someone ahead :-).

I have fixed the issue and it is working as expected. The only thing i did is I have handled OnDrawItem twice, So I have to disable this at component designing.

You should make sure that the corresponding column of your datatable is not of an integer type. If the given column is some kind of integer this condition is then reflected in the datagrid column and when you enter values with decimals they are casted back to integer.

Are there any compiler defines or functions/constants/variables that can be used to tell whether some code is being built for a design time package or is being executed from inside the IDE?

No.

We have some code hooks that we setup in the initialization of a unit which is part of a package. We don't want this code to be executed when installing the package in the IDE, only when it's running as part of our application.

Then that code does not belong in the unit's initialization section at all. Move it to a separate function that your application code can call during its startup.

For now I have added a compiler define to the design time package which strips out the code

That implies that your design-time package is directly compiling your run-time code, which it should not be doing at all. Run-time code and design-time code need to be in separate packages. Run-time code does not belong in a design-time package, and design-time code does not belong in a run-time package.

I was wondering if there was a built in compiler define that indicates that this is part of a design time package

There is not. However, if you create separate run-time and design-time packages (as you should be), then your hook code belongs in the run-time package only. The design-time package can require the run-time package (so it has access to your run-time components), and the run-time package can expose a global variable that the design-time package can set. The run-time code can then ignore whatever it needs to ignore if that variable is set.

What you describe should not be possible under normal conditions.

There are only two places in the entire VCL where CM_APPSYSCOMMAND is sent from:

1. TWinControl.WMSysCommand(), which is called when a UI control receives a WM_SYSCOMMAND message. The LParam of the CM_APPSYSCOMMAND message is never set to 0, it is set to a pointer to the TMessage record of the original WM_SYSCOMMAND message:

Lets consider this code:

As have been established in the comments to the question, the hint does not stay on the screen indefinitely but it is actually continuously re-shown as soon as it is hidden.

The reason for that is, the VCL assumes the hint control to be a child window, that's because it's Parent property is not nil. In the case of the code in the question, although the month calendar floats by mutating it to be a popup window, its parent is still the form as far as the VCL knows it. This causes the calculation for the hint rectangle in ActivateHint procedure of the Application to go wrong. On the other hand, HintMouseMessage procedure of the Application does not care if the control is parented or not. What happens then is, although you don't move the mouse pointer on the control, VCL infers the mouse pointer continuously leaves the hint boundary and then re-enters.

Here is a simplified reproduction for the problem: