Mfc gdi dual-buffer prevents image flashing and reprinting

How to implement dual Buffering

The implementation program is provided first, and then explained again, also in ondraw (CDC * PDC:

CDC memdc; // define a display device object

Cbitmap membitmap; // defines a bitmap object.

// Create a memory display device compatible with Screen Display

Memdc. createcompatibledc (null );

// No drawing yet, because there is no place to draw ^_^

// A bitmap compatible with screen display is created below. The size of the bitmap can be set to the size of the window.

Membitmap. createcompatiblebitmap (PDC, nwidth, nheight );

// Select the bitmap to the memory display device.

// Only the memory display device with the bitmap selected can draw a local image and draw it to the specified bitmap.

Cbitmap * poldbit = memdc. SelectObject (& membitmap );

// Use the background color to clear the bitmap. Here, I use white as the background color.

// You can also use your own color

Memdc. fillsolidrect (255,255,255, nwidth, nheight, RGB ));

// Drawing

Memdc. moveTo (......);

Memdc. lineto (......);

// Copy the image in the memory to the screen for display

PDC-> bitblt (0, 0, nwidth, nheight, & memdc, 0, srccopy );

// Cleanup after drawing is complete

Membitmap. deleteobject ();

Memdc. deletedc ();

Disable the system from erasing the original image.

You can reload the onerasebkgnd () function so that it can directly return true. For example

Bool cmywin: onerasebkgnd (CDC * PDC)

{

Return true;

// Return cwnd: onerasebkgnd (PDC); // comment out the original statement of the system.

}

Most people think that the plotting function of MFC is very inefficient and they always want to seek other solutions.

The drawing efficiency of MFC is indeed not high, but it is not bad, and its drawing function is very simple to use,

As long as you use the appropriate method and add some tips, you can use MFC to get a very efficient drawing program.

I 'd like to talk about my long-term experience in using MFC plotting (Oh, of course, I only have more than two years ).

Some of my points.

1. Why does the displayed image flash?

Most of our drawing processes are stored in the ondraw or onpaint functions, while ondraw is performing screen operations.

Onpaint calls the screen display. When the window needs to be re-painted for any reason,

Always clear the display area with the background color before calling onpaint.

In this way, the background color and the display image appear alternately in a short time, making the display window look like

In the flash. If you set the background to null, the duplicate drawing will not flash.

Of course, this will make the display of the window messy, because there is no background color for the original

The drawn image is cleared, and the new image is superimposed.

Some people may say that flashing is caused by the drawing speed being too slow or the graphics displayed are too complex,

In fact, this is not true. The influence of the display speed of the drawing on the flicker is not fundamental.

For example, in ondraw (CDC * PDC), write as follows:

PDC-> moveTo (0, 0 );

PDC-> lineto (100,100 );

This drawing process should be very simple and fast, but we will still see it when pulling the window changes.

Flashing. In fact, in principle, the more complex the drawing process, the slower the drawing process, the less flickering, because

The larger the ratio of time spent on clearing the screen with the background, the less obvious a person will feel.

For example, if the screen time is 1 s, the drawing time is also 1 s, so that the continuous re-painting within 10 s will flash.

5; if the screen time is 1 S, and the drawing time is 9 s, the continuous re-painting within 10 s

It will only Flash once. This can also be tested by writing in ondraw (CDC * PDC) as follows:

For (INT I = 0; I <100000; I ++)

{

PDC-> moveTo (0, I );

PDC-> lineto (1000, I );

}

The program is abnormal, but the problem can be explained.

Some people may want to explain why a simple image does not look as complex.

Why? This is because the complex image occupies a large area and the contrast caused by the re-painting is relatively large.

But the flash frequency is low.

So why does the animation appear non-flashing when its re-painting frequency is high? Here, I will emphasize again,

What is flashing? Flashing means contrast. The larger the contrast, the more powerful the blinking. Because the animation has two consecutive frames.

The difference is very small, so it does not seem to flash. If you do not believe it, you can add a pure white frame between each frame of the animation,

It's not surprising that we don't have a flash.

2. How to Avoid blinking

After you know why the image flash, you can do the right thing. First of all, remove the MFC

The background rendering process is provided. There are many implementation methods,

* When the window is formed, you can pay NULL for the registration background of the window.

* You can also modify the background after the formation.

Static cbrush brush (RGB (255, 0, 0 ));

Setclasslong (this-> m_hwnd, gcl_hbrbackground, (long) (hbrush) brush );

* You can also load onerasebkgnd (CDC * PDC) to return true directly.

In this way, the background is gone, and the result graphic display is indeed not flashing, but the display is also as mentioned above,

A mess. What should I do? This requires the dual-Cache method. The dual buffer is not only available on the screen

In addition to displaying images, there are also images in the memory. We can plot the image to be displayed in the memory first, and then overwrite the image in the memory to the screen one by one point at a time (this process is very fast, because it is a very regular copy of memory ). In this way, when drawing in the memory, any background color with a large contrast will not flash, because it cannot be seen. When it is attached to the screen, the final image in the memory is slightly different from the screen display image (if there is no motion, of course there is no difference), so that it will not flash.

3. How to implement dual Buffering

The implementation program is provided first, and then explained again, also in ondraw (CDC * PDC:

CDC memdc; // define a display device object

Cbitmap membitmap; // defines a bitmap object.

// Create a memory display device compatible with Screen Display

Memdc. createcompatibledc (null );

// No drawing yet, because there is no place to draw ^_^

// A bitmap compatible with screen display is created below. The size of the bitmap can be set to the size of the window.

Membitmap. createcompatiblebitmap (PDC, nwidth, nheight );

 

// Select the bitmap to the memory display device.

// Only the memory display device with the bitmap selected can draw a local image and draw it to the specified bitmap.

Cbitmap * poldbit = memdc. SelectObject (& membitmap );

// Use the background color to clear the bitmap. Here, I use white as the background color.

// You can also use your own color

Memdc. fillsolidrect (255,255,255, nwidth, nheight, RGB ));

// Drawing

Memdc. moveTo (......);

Memdc. lineto (......);

 

// Copy the image in the memory to the screen for display

PDC-> bitblt (0, 0, nwidth, nheight, & memdc, 0, srccopy );

// Cleanup after drawing is complete

Membitmap. deleteobject ();

Memdc. deletedc ();

The above comment should be very detailed, so I will not talk much about it.

4. How to Improve the drawing efficiency

I am mainly working on the CAD software for the Network Graphics of the power system. In a window, thousands of power components are usually displayed, and each component is composed of basic figures such as points, lines, and circles. If you really want to re-draw so many elements in a re-painting process, it can be imagined that this process is very long. If you have added the Image Browsing function, you need to re-paint a lot when you move the mouse to scroll the image. The speed will be too slow for users to endure. What should I do? We only need to study the Drawing Process of MFC.

In fact, not all charts drawn in ondraw (CDC * PDC) are displayed. For example, you

Two rectangles are drawn in ondraw. In one re-painting, although the drawing functions of both rectangles are executed, there may be only one display, this is because MFC sets the cropping area to improve the repainting efficiency. The purpose of the cropping area is to ensure that only the plotting process in this area is valid and that the plotting function is not displayed even if it is executed outside the area. In most cases, the re-painting of a window is mostly due to partial occlusion of the window or scrolling of the window. The changed area is not the whole graph but only a small part, this part needs to be changed in the cutting area of the PDC. Because the display (display to memory or video memory) is much more time-consuming than the calculation of the drawing process, only the display part should be displayed after the cropping area, greatly improving the display efficiency. However, this cropping area is set by MFC, which has improved the display efficiency. How can we further improve the efficiency when drawing complex images? Then, only the plotting process outside the cropping area is removed. You can first use PDC-> getclipbox () to obtain the cropping area, and then determine whether your image is in this area during the drawing. If you are painting it, you will not draw it if you are not.

If your drawing process is not complex, this may not improve your drawing efficiency.

Double keyword Buffer

Name of original author Qi Gao

Introduction

I often see posts on the page flickering during refresh in the forum. How can I control the effect of no page blinking during efficient drawing? I will explain the double buffering method below.

Body

The reason why the image flashes is that most of our drawing processes are stored in the ondraw or onpaint function, and ondraw calls the onpaint function for screen display. When the window needs to be re-painted for any reason, the display area is always cleared with the background color before onpaint is called. The background color is often in a large contrast with the drawing content, in this way, the background color and the display image appear alternately in a short period of time, making the display window appear flashing. If you set the background to null, the duplicate drawing will not flash. Of course, this will make the display of the window messy, because during the re-painting, there is no background color to clear the original drawing, and a new image is superimposed. Some people may say that the blinking is caused by the drawing speed being too slow or the display graphics being too complex. In fact, this is not true. The influence of the display speed of the drawing on the flashing is not fundamental.

How to implement dual buffering: In ondraw (CDC * PDC:

CDC memdc; // define a display device object

Cbitmap membitmap; // defines a bitmap object.

// Create a memory display device compatible with Screen Display

Memdc. createcompatibledc (null );

// No drawing yet, because there is no place to draw ^_^

// A bitmap compatible with screen display is created below. The size of the bitmap can be set to the size of the window.

Membitmap. createcompatiblebitmap (PDC, nwidth, nheight );

// Select the bitmap to the memory display device.

// Only the memory display device with the bitmap selected can draw a local image and draw it to the specified bitmap.

Cbitmap * poldbit = memdc. SelectObject (& membitmap );

// Use the background color to clear the bitmap. Here, I use white as the background color.

// You can also use your own color

Memdc. fillsolidrect (255,255,255, nwidth, nheight, RGB ));

// Drawing

Memdc. moveTo (......);

Memdc. lineto (......);

// Copy the image in the memory to the screen for display

PDC-> bitblt (0, 0, nwidth, nheight, & memdc, 0, srccopy );

// Cleanup after drawing is complete

Membitmap. deleteobject ();

Memdc. deletedc ();

Take a forum post as an example to illustrate how to solve the problem.

The post content is:

I want to move a region,

How to solve the problem of area flickering when the window is refreshed.

Void cjhkljklview: ondraw (CDC * PDC)

{

Cjhkljkldoc * pdoc = getdocument ();

Assert_valid (pdoc );

// Todo: Add draw code for native data here

Int I;

Int X [20], Y [20];

Cpen Hpen;

Point W [5];



X [0] = A/100 + 10;

X [1] = A/100 + 30;

X [2] = A/100 + 80;

X [3] = A/100 + 30;

X [4] = A/100 + 10;

Y [0] = 10;

Y [1] = 10;

Y [2] = 25;

Y [3] = 40;

Y [4] = 40;

For (I = 0; I <5; I ++)

{W [I]. x = x [I];

W [I]. Y = Y [I];

}

// Cclientdc (this );

// Hpen = createpen (ps_solid, 1, RGB (255, 0 ));

Crgn argn, brgn;

Cbrush abrush (RGB (40, 30, 20 ));

Argn. createpolygonrgn (W, 5, 1); // point is a cpoint array,

PDC-> fillrgn (& argn, & abrush );

Abrush. deleteobject ();

}

Void cjhkljklview: ontimer (uint nidevent)

{

// Todo: add your message handler code here and/or call default

Invalidaterect (null, true );

Updatewindow ();

A ++ = 100;

Cview: ontimer (nidevent );

}

Int cjhkljklview: oncreate (maid)

{

If (cview: oncreate (lpcreatestruct) =-1)

Return-1;



// Todo: add your specialized creation code here

Settimer (1, 10, null );

Return 0;

}

The timer is used to directly refresh the screen within 10 milliseconds, so that the effect will flash continuously.

The solution is to trigger wm_erasebkgnd with double buffering, and then modify to return true;

Define variables:

Cbitmap * m_pbitmapoldbackground;

Cbitmap m_bitmapbackground;

CDC m_dcbackground;

// Draw the background

If (m_dcbackground.getsafehdc () = NULL | (m_bitmapbackground.m_hobject = NULL ))

{

M_dcbackground.createcompatibledc (& DC );

M_bitmapbackground.createcompatiblebitmap (& DC, rect. Width (), rect. Height ());

M_pbitmapoldbackground = m_dcbackground.selectobject (& m_bitmapbackground );

// Drawmeterbackground (& m_dcbackground, rect );

Cbrush brushfill, * pbrushold;

// Black background color

Brushfill. deleteobject ();

Brushfill. createsolidbrush (RGB (255,255,255 ));

Pbrushold = m_dcbackground.selectobject (& brushfill );

M_dcbackground.rectangle (rect );

M_dcbackground.selectobject (pbrushold );

}

Memdc. bitblt (0, 0, rect. Width (), rect. Height (),

& M_dcbackground, 0, 0, srccopy );

// Draw the image

Int I;

Int X [20], Y [20];

Cpen Hpen;

Point W [5];



X [0] = A/100 + 10;

X [1] = A/100 + 30;

X [2] = A/100 + 80;

X [3] = A/100 + 30;

X [4] = A/100 + 10;



Y [0] = 10;

Y [1] = 10;

Y [2] = 25;

Y [3] = 40;

Y [4] = 40;







For (I = 0; I <5; I ++)

{W [I]. x = x [I];

W [I]. Y = Y [I];

}

// Cclientdc (this );

// Hpen = createpen (ps_solid, 1, RGB (255, 0 ));

Crgn argn, brgn;

Cbrush abrush (RGB (40, 30, 20 ));

Argn. createpolygonrgn (W, 5, 1); // point is a cpoint array,

Memdc. fillrgn (& argn, & abrush );

Abrush. deleteobject ();

}

In this way, the screen will not flash when you compile and run the program.