As a suggestion, most people aren't going to acknowledge an update of something simple, i.e. a graph or chart, more than twice a second. If you are wanting to animate using a TImage by drawing to the Canvas, I recommend using a TAnimate instead if possible.
Note that the reason the TImage flickers is because of the erase_background being forced to true by the compiler. Borland likes to hide a lot of the inner workings to make things easier, but this is one of the biggest causes of flicker that gets most native Borland programmers (who never wrote applications with MSVC where you had to decide each time you validate a window whether to erase it's background or not).
See, when the TImage erases the background, it goes ahead and draws it erased if the vertical refresh is up. The vertical refresh is when the electron beam in the monitor has drawn the whole screen but has to return from one corner back to the opposite corner. During this time is when most memory on the device is updated. What happens is that the memory receives the "Erase" data (which is probably just the background color), then the vertical refresh occurs and the memory is locked, the image is drawn to screen, and your code was interrupted before it could draw the next portion of the TImage. Hence, your image disappears for a frame once in a while.
This is where double buffering comes into play. This was a common problem with old games, so they would create 2 buffers of memory on the video card and begin displaying buffer 1 (called the primary buffer) by setting a register or memory location in the video card indicating the address of the buffer to display (the address of buffer 1). They would then take as long as they needed to copy the image data to buffer 2 (secondary buffer), then change the register in the video card to reflect the address of buffer 2. Now buffer 2 is the primary buffer and is being displayed, and the program starts the next frame off by updating buffer 1 (the secondary buffer). Each frame, they would flip the buffers, hence double buffering and the prevention of "tearing" of the image on screen.
You can create a new component, based on TGraphicControl. Update the OnPaint event handler to do the following:
What you want to do is create a static Graphics::TBitmap *Buffer at program startup. Every frame (say we choose 2 Hz), you update the Buffer with all of the drawing that needs to take place. At the end of the frame, you say "Canvas->Draw(0, 0, Buffer);"
Using a simple bar graph as an example, which can get pretty complicated and time consuming redrawing every part, you could create a Buffer for each part of the graph. The background would be a Buffer. That might contain just the background color, a rectangle, the numbers, and marks out to the side of the graph. Then you might have another Buffer for the bars, which may be constantly changing but require much less time to process, since you're just drawing rectangles. At the end of every frame, you would call:
Buffer->Draw(0, 0, BackBuffer);
Buffer->Draw(0, 0, BarBuffer);
Canvas->Draw(0, 0, Buffer);
Just keep in mind that all of the canvases must be the same width and height to prevent distortion. Also note that the Canvas->Draw...that Canvas is the main canvas of the component you are creating.
Hope this helps,
Chris
