VC plot to solve the problem of pop-up Screen

There are many questions about how to avoid flickering and how to improve the display efficiency. Most people think that the efficiency of the MFC plot function is very low, 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 the use of appropriate methods, plus some skills, with MFC can get a very efficient drawing program.
I would like to share some of my views on my long-term experience in using MFC plotting (of course, I only have more than two years.

1. Why does the displayed image flash?
Most of our drawing processes are stored in the ondraw or onpaint functions. ondraw calls onpaint for screen display. When the window needs to be re-painted for any reason, it always clears the display area with the background color before calling onpaint,
The background color is often in a big 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, redraw the image
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 may say that flashing is because of painting.
The speed of a graph is too slow or the graphic display is too complex. In fact, this is not true. The effect of the display speed on the flickering 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 it will still flash when pulling the window changes. In fact, in principle, the more complex the drawing process, the slower the drawing process, and the less flickering, because of the time and use of the drawing.
The larger the percentage of time the background takes to clear the screen, the less obvious the 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 times; for example
If the screen time is 1 S, and the drawing time is 9 s, the continuous re-painting within 10 s 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 talk about it again. Why does a simple image look like a complex one? This is because the area occupied by complex images is large, and the contrast caused by re-painting is relatively large, so I feel like it will flash badly.
Some, but the flicker frequency is low. So why does the animation appear non-flashing when its re-painting frequency is high? Here, I want to emphasize again, what is flashing? Flashing means contrast. The larger the contrast, the more powerful the blinking. Because
The difference between two consecutive frames is very small, so it does not seem to flash. If you don't believe it, you can add a pure white frame in the middle of each frame of the animation.


2. How to Avoid blinking
After you know why the image flash, you can do the right thing. The first step is to remove the background rendering process provided by MFC. 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.
 

The background is gone, and the result graphic display does not flash, but the display is also messy as mentioned above. What should I do? This requires the dual-Cache method. In addition to the image input on the screen
In addition to row display, some images are also being drawn in 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.
The 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
There is little difference between the image and the screen display image (if there is no motion, of course there is no difference), so that it does not seem to 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 want to duplicate
It can be imagined that the painting process involves many elements. 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.
Two rectangles are drawn. In a re-painting, although the two rectangles are all executed, there may be only one display, this is because MFC sets the cropping area to improve the repainting efficiency. Cropping Area
The role is: only the drawing process in this area will be truly effective, and the outside is invalid, even if the drawing function is executed outside the area, it will not be displayed. In most cases, the re-painting of Windows is mainly caused
If the part of the window is blocked or the window is rolled, the changed area is not the whole graph but only a small part. The part that needs to be changed is the cropping area in the PDC. Because it is displayed (both in memory and in Memory)
It is much more time-consuming than the calculation of the drawing process. With the cropping area, only the display part is displayed, which greatly improves the display efficiency. However, this cropping area is set by MFC, and it has been improved for us.
How can we further improve the display efficiency when drawing complex images? Then, only the plotting process outside the cropping area is removed. You can use PDC-> getclipbox () to obtain the cut.
Cut area, and then judge whether your image is in this area during the drawing. If it is in, it will not be painted.
If your drawing process is not complex, this may not improve your drawing efficiency.

From: http://topic.csdn.net/t/20021216/10/1264310.html