BorlandTalk.com

dMessett · Guest

Greetings people.

I've spent the last several hours trying to figure this one out, and
I've come up with a workaround, but I'm not sure that I understand the
nature of the problem, that of why the PaintBox contents *sometimes*
disappear when first written, but contents appear when written a second
time.

Ya see, I have a simple game app (minesweeper ripoff) that uses a
function to configure stuff, which resizes visual controls amongst which
is, the paintbox that is my lament. The function itself does not do
anything to the paintbox other than resize it, and enable it.

This function is called in Form1.OnCreate, after which my procedures
that draw on the canvas of the paintbox, deliver immediate results.

Now here's the part that confuses me. If I call my function a second
time once the app is running, with the *same* parameters as were used
when calling this function in Form1.OnCreate (which would set
paintbox.width & height to what they were already set at within
Form1.OnCreate), I can afterward draw on the paintbox and have the
results appear immediately. If however I invoke my function (second
time, given that it was already invoked in Form1.OnCreate) with
different arguments (which resizes the paintbox), writing the paintbox
afterward flashes briefly & disappears on the first try, but on the
second try, it's fine.

The simple trial & error fix-all was to stick a seemingly redundant
'refresh' at the tail end of my function, but the drawing operations
themselves are outside of the scope of that function, thus I don't get
why "refreshing" the paintbox BEFORE its canvas is drawn somehow
corrects the problem of otherwise having to draw its canvas TWICE within
the app if the paintbox is resized (within the app), given that I only
have to draw ONCE (within the app) if the paintbox was sized ONCE (again
via my function) from within Form1.OnCreate... does that make sense?
Sizing of the paintbox within the IDE is dissimilar to that which I set
it as (by default or otherwise) within the app BTW, and doublebuffering
whether true or false has no relevancy.

If you can shed light on this situation, I would be grateful for any
insight. I've remedied the problem, but I don't understand its exact
cause. Any thoughts?

TIA, DHM

Yorai Aminov (TeamB) · Guest

dMessett wrote:

RandomAccess · Guest

Here's how I do stuff like this :

a) I always create 2 bitmaps the same size as my paintbox. A "work"
bitmap and a "display" bitmap. ( NOTE : The bitmaps MUST change size if the
paintbox changes size - and this will require some special handling by you).

b) I always draw new "frames" to my "work" bitmap and NOT to the paintbox.
When a new frame is drawn, the bitmap that was drawn to becomes the
"display" bitmap and the other bitmap becomes the "work" bitmap. You will
need to create some special flags (variables) to manage this. The best
thing to do is to wrap it all into a class.

c) The paintbox OnPaint event simply draws my "display" TBitmap.
ie MyPaintBox.Canvas.Draw(0, 0, DisplayBitmap);

What (c) does, is it gaurentees the paintbox always draws the last fully
built frame. The on-paint event of the paintbox can fire for any number of
different reasons, so that's why you need this code here.

AFTER drawing a NEW frame into your "work" bitmap, you will want to
obviously draw it to the screen immediately. I prefer to make a direct call
to the on-paint handler of the paint box once a frame is drawn - instead of
calling something like MyPaintbox.Repaint.

ie

.... drawing the frame
SwapBitmaps; // Swap flags for Work and Display bitmaps
MyPaintBoxPaint(MyPaintBox); // Call the event handler directly

Actually, my paintbox event handler calls a blitting routine, and that's
the routine that I call AFTER creating a new frame. In any case it's all
the same thing.

hope this helps.

Best Regards

dMessett · Guest

Yorai Aminov (TeamB) wrote:

dMessett · Guest

RandomAccess wrote:

RandomAccess · Guest

Hi Dustin,

Roger Lascelles · Guest

"Yorai Aminov (TeamB)" <yaminov (AT) gmail (DOT) com> wrote

dMessett · Guest

Roger Lascelles wrote:

dMessett · Guest

RandomAccess wrote:

RandomAccess · Guest

You've got it exactly. I learned this after doing stuff like this for years
and endlessly tweaking my code. There are some down-sides though. If the
paintbox is too big and the renderer is too slow, you'll definately
notice - because the technique is better suited when used with DirectX or
something like that which can helk with rendering speed.

So generally all you can do is make the renderer as fast as possible.
Some people like to render directly in On-paint without buffering and this
actually works quite well if you use a modified paintbox which doesn't erase
the background. But I myself usaully prefer double buffering as I've
pointed out.

The application itself will determine the best approach to use.

best regards