ttimer | Terminal countdown timer , written in Go | Command Line Interface library

TIdTCPServer is a multi-threaded component. Its OnExecute event is called in the context of a worker thread. As such, it MUST synchronize with the main UI thread when accessing UI controls (that goes for ShowMessage() too, BTW). You can use the RTL's TThread::Synchronize() (synchronous) or TThread::Queue() (asynchronous) method for that.

Also, you should not be Free()'ing the TListBoxItem objects directly. You have the index of the desired item, you can use ListBoxPrep->Items->Delete() instead.

If you are using one of the clang-based compilers, try something more like this:

The TTimer is being constructed in the main UI thread, when the TForm streams in its DFM resource. The TTimer's constructor creates an internal HWND for the timer to receive WM_TIMER messages with. That HWND is thus owned by the main UI thread.

TForm.Notify() is setting the timer's Enabled property to true, which will call SetTimer(). Notify() is being called in the context of the worker thread, not the main UI thread. This SHOULD NOT work, as stated in SetTimer()'s documentation. Only the main UI thread should be able to start the timer running, since the main UI thread owns the timer's HWND.

TTimer.UpdateTimer(), which is called internally by the setters of the timer's Enabled, Interval and OnTimer properties, will raise an EOutOfResources exception if SetTimer() fails. So, calling form1.Notify() in TypeThreadTest.Execute() SHOULD NOT work. The only way SetTimer() would not be called in that situation is if either:

• Interval is 0
• Enabled is false
• OnTimer is unassigned

Otherwise, your worker thread SHOULD be crashing.

As you have noted, your worker thread can alternatively use TThread.Synchronize() (or TThread.Queue()), or PostMessage() (or SendMessage()), when it wants to notify the main UI thread to do something. These are viable and preferred solutions. Personally, I would opt for TThread.Queue(), eg:

Your code is almost OK.

As far as I can see your problem is caused by not completely restoring the background before you draw the bitmaps at their new locations. You need to restore the old rects of all spheres before you draw the new ones. Also you need to collect the complete union of all new and old rects before you update to screen.

As a matter of taste, I would avoid the global variables and make them fields of the form. If you also make PictureStorage a method of the form, everything works.

The timer interval of 1 seems a bit of an overkill. I would set it to 1000 div 120 (120 FPS).

I would set doublebuffered to false, as you are already doing your own doublebuffering. Also I would move the form's OnPaint to the paintbox's OnPaint, but that doesn't seem to work for you.

Here is the replacement of the OnTimer event which should work (I checked an analogue with Delphi 2006, I don't have Delphi7 installed anymore and I don't know what the n means).

Is it possible to call it like that, directly

It is not safe to do so. Always Synchronize when changing the state of VCL components being used in the main VCL thread from from a thread that is not the main VCL thread.

You can use the static TThread::Synchronize function from with a lambda function that will be executed in the main VCL thread:

Most often, an invalid-pointer exception means that you try to free an object twice.

The problem in this case is that a control frees its children when it is freed. So when the form is freed, it also frees the TLabel. Thus, when your TTrackBarLabel.Destroy is executed, your FLabel is a dangling pointer, and you mustn't do FLabel.Free.

All Delphi developers know that a component frees its owned components when it is freed. It is a less known fact that a control also frees its children.

In your case, you can simply remove the FLabel.Free. However, this will cause a memory leak if you never set the FLabel's Parent property.

To make sure the label is automatically freed when the track bar is, make the track bar the owner of the label:

I designed a simple example where when the user click the mouse on a TButton, it simulate a keystroke every 250mS until the user release the mouse button.

The OnMouseButtonDown starts a 250mS timer, the OnMouseButtonUp stop the timer. The OnTimer send the keyboard event. The timer is also stopped when the mouse leave the form.

The .PAS file:

You can do that in two ways:

1. Add a JavaScript function in the "onclick" event of that button. That function would only have to call "console.log()" with "OpenMyNewFormInDelphi" or whatever you want as the text parameter. Then use the TChromium.OnConsoleMessage event and check the "aMessage" parameter. In case aMessage has "OpenMyNewFormInDelphi" then send a Windows message to the main form to show your new form in the main application thread. This solution is the easiest, it's not very elegant but it gets the work done. See the DOMVisitor demo for more details.
2. You can also register a "JavaScript extension" with CEF4Delphi to execute Delphi code from JavaScript. This is by far the most complicated solution because it involves the creation and registration of a custom class inherited from TCefv8HandlerOwn. That class will receive the calls from your JS code and you can send an IPC message to the main browser process if your application needs to do something in response to that JS call. See the JSExtension and JSRTTIExtension demos for more information.

The full explanation for the JavaScript extension is a bit long but you can read it here : https://github.com/salvadordf/CEF4Delphi/blob/d44db3bf2a3ead0654ca90178161b09bfbe33602/demos/Delphi_VCL/JavaScript/JSExtension/uJSExtension.pas#L122

Please remember that all TChromium and GlobalCEFApp events are executed in a CEF thread that it's different than the main application thread. The VCL is not thread safe and you may have problems if you create, destroy or modify Windows controls inside those events. The CEF4Delphi demos are oversimplified and you should always move the VCL code outside the those events. The first solution sends a Windows message to the main form for this reason.

In your object's constructor, you are creating a TTimer ok, but you are setting its Enabled property to False. So make sure you actually activate the timer once the constructor has exited. Or else change False to True in the constructor.

That being said, your code still won't work as shown. This is because TIdHTTPServer is a multi-threaded component, its OnCommand... events are fired in the context of worker threads that TIdHTTPServer creates for itself when clients connect to the server. But TTimer is a message-based timer, it creates an internal HWND for itself which is tied to the thread that it is created in, and that thread must have a message loop in order for TTimer to process WM_TIMER messages. The worker thread that you are creating your TTimer in does not have a message loop, so the TTimer will not be able to fire its OnTimer event.

So, you will have to either:

1. run your own message loop inside of the OnCommand... event handler after creating your object, and then free the object before the event handler exits. There is no guarantee that the calling thread will continue running once the OnCommand... event handler has exited. Just note that the client will be blocked from sending any further HTTP commands to the server while the timer is running:

I've found something about this. If you use SIGEV_THREAD_ID, the timer will send a signal to the thread id. So you have to install a signal handler in the thread and the function catch_alarm won't be called, just the signal handler, but in the thread.

If you use SIGEV_THREAD, then the function catch_alarm will be called, but you can't set the thread id as it will be created on your behalf.

The following code works as you expect: