MFC Programming Tecnics

Transcription

1 Itay Danielli 1 MFC Programming Tecnics In a Dos operating system, each hardware device had to be supplied with a device driver. A program wishing to use the device needed to know all the device commands and use it directly. In windows 95, each driver is handled by the operating system standard functions. the application address the hardware threw the operating system using the Device Context which wrap the Device -> Apllication interactions. This capability to work with a wide variety of output devices, often referred to as device independence, means that the developer does not have to deal with the differences between the types of output devices. Access to the GDI is provided primarily through the CDC class and its derivatives. A device context (DC) is a data structure containing fields that describe the information that the GDI needs to know about the display surface as well as the context in which it is being used. Once you have a DC, you can use a variety of GDI objects to draw lines, geometric shapes, and text to a view in your application. In Windows, a DC does the following: Gives permission to an application to use an output device. Provides a link between a Windows-based application, a device driver, and an output device, such as a monitor or printer. Maintains current information about how to draw or paint to a window, such as the colors, brush or pen patterns, pen widths, and so on. Maintains a clipping region for a window, which limits the program output to the areas of the output device covered by the window. MFC encapsulates device context capabilities through the CDC class. The core of this class is the data member m_hdc, which represents a handle to a Windows DC.

2 Itay Danielli 2 Outputting to a device context The OnDraw function is called when the view becomes stale and needs to be refreshed. Whenever a window or portion of a window needs to be repainted, the operating system sends it a WM_PAINT message with information on what portion of the window needs to be repainted. In the MFC framework, this information is given to CWnd::OnPaint, which creates a DC of the appropriate type and calls the OnDraw function for the view. Other functions such as print may use the OnDraw() function, supplying it with a driven DC. This way all DC will display the data in the same way. Two common methods to access a device context (DC) in an MFC application: Receiving a pointer to a CDC object as a function parameter. Some message handlers receive a pointer to a CDC object that is used to perform display operations. void CMyView::OnDraw(CDC* pdc) { CMyDoc* pdoc = GetDocument(); ASSERT_VALID(pDoc); // Draw a black dot at location 10,10 pdc->setpixel(cpoint(10,10), RGB(0,0,0)); // Use DC pointer. } Creating a temporary, local CDC object by using any of the CDC-derived classes: void CMyView::OnLButtonDown(UINT nflags, CPoint point) { CClientDC dc(this); dc.setpixel(point, RGB(0,0,0)); CView::OnLButtonDown(nFlags, point); } Note Because the DC was created on the stack, it is released by the DC-object destructor when the local object dc goes out of scope. This returns the resource and memory to the system.

3 Itay Danielli 3 Using CDC class The CDC class defines a class of device context objects. The CDC class provides member functions for device context operations, working with drawing tools, graphics device interface (GDI) object selection, working with colors and palettes, drawing text. There are four CDC-derived classes that provide specialized device contexts. CClientDC CPaintDC CWindowDC CMetafileDC Client area of a window Invalid region of a client area Client and nonclient areas A metafile. * You can also use a CDC object to create a memory device context, which is compatible with an existing DC. This would be useful for preparing images in memory before you transfer them to the device. Colors - In Windows, colors for both text and graphics are represented by a 32-bit value. MFC and SDK developers use the COLORREF data type using a range of 0 255, for each of the red, green, and blue color components. Windows provides the macros RGB, which returns the COLORREF value based on the component values. Also the GetRValue, GetGValue, GetBValue which returns the Red, Green, Bleu component of a COLORREF value. For example - COLORREF color = RGB(12,34,56); CBrush brush(color); TRACE("The Red component of the brush is %d\n", GetRValue(color)); A simple example of painting text to the screen uses the derived class CPaintDC, called from the OnPaint member function. The following example code shows you how to paint a single line of text to the center of the screen, using the DrawText member function: void CMyView::OnPaint() { CPaintDC dc(this); CRect rect; GetClientRect(&rect); dc.drawtext("hello world", -1, &rect, DT_SINGLELINE DT_CENTER DT_VCENTER); }

4 Itay Danielli 4 drawing shapes: Pixel Manipulation - CDC::SetPixel, CDC::GetPixel. void CMyView::OnDraw(CDC* pdc) { // Draw a red dot at location 100, 100 pdc->setpixel(cpoint(100,100), RGB(255, 0, 0)); } Line Drawing Functions - Draw line segments using the CDC::MoveTo and CDC::LineTo functions. The CDC::MoveTo function is used to set the starting position for a pen. The CDC::LineTo function then draws a line from the starting position to the new position. This new position then becomes the current position and further CDC::LineTo functions can be called. Polyline - CDC::Polyline can be used to draw a set of line segments connecting the points that are specified in an array of POINT structures or CPoint objects. The lines are drawn from the first point through subsequent points by using the current pen. Unlike the LineTo member function, the Polyline function neither uses nor updates the current position. Rectangle - CDC::Rectangle draws a rectangle by using the current pen for the border and the current brush for the interior of the rectangle. Ellipse - CDC::Ellipse draws an ellipse by using the current pen for the border and the current brush for the interior of the rectangle. Polygon - CDC::Polygon draws a polygon from an array of points. FrameRect - CDC::FrameRect draws a rectangular border with a supplied brush. FillRect - CDC::FillRect fills a rectangular area with a supplied brush. CDC Text Output Functions: TextOut Displays a text string at the given location by using the currently selected font, colors, and alignment. TabbedTextOut Similar to TextOut, but supports expansion of tab stops. DrawText Displays formatted text within a bounding rectangle. ExtTextOut Similar to TextOut, but allows specification of clipping options. SetTextColor and GetTextColor Control the color of the text displayed. SetBkMode and GetBkMode Control whether or not the cells that surround each letter are filled before the corresponding characters are displayed. In Opaque mode, the cells are filled with the current background color. In Transparent mode, no fill takes place. SetBkColor and GetBkColor Control the color of the cells that contain the displayed text. The background mode must be Opaque before this attribute is used in a fill. SetTextAlign and GetTextAlign Control the alignment of text relative to the window position specified in one of the text output functions.

5 Itay Danielli 5 CDC object used to create a memory device context, which is compatible with an existing DC. There are four CDC-derived classes that provide specialized device contexts. CClientDC Client area of a window CPaintDC Invalid region of a client area CWindowDC Client and nonclient areas CMetafileDC A metafile Example code shows how to paint a single line of text to the center of the screen: void CMyView::OnPaint() { CPaintDC dc(this); CRect rect; GetClientRect(&rect); dc.drawtext("hello world", -1, &rect, DT_SINGLELINE DT_CENTER DT_VCENTER); } Example code shows how to display simple text in the view void CSimpleTextView::OnLButtonDown(UINT nflags, CPoint point) { CClientDC dc(this); dc.settextcolor(rgb(0, 0, 255)); dc.textout(point.x, point.y, "Hello"); CView::OnLButtonDown(nFlags, point); }

6 Itay Danielli 6 GUI objects MFC provides classes for creating custom GDI objects. To define a GDI object, you simply create an object using the class constructor. If you use a constructor with no arguments, then one of the, create functions should be called to initialize it. The advantage of the latter method is that a constructor using no arguments will never throw an exception. CPen mypen1(ps_solid, m_penthickness, RGB(255,0,0)); // Method number 1. CPen mypen2; // Method number 2 MyPen2.CreatePen(PS_SOLID, 0, RGB(255,0,0)); Default - When a CDC object is created, it gains a set of system default values as attributes and GDI objects. To manage attributes - the CDC class contains a number of member functions. For example, CDC::GetTextColor and CDC::SetTextColor can be used to manage the color of text as it is drawn. Overriding the Defaults - To change a GDI object from the default, you must select a new object into the DC. The SelectObject selects the new object into the context and then returns the old object. Typically, this returned object is saved. When the drawing operation is complete, the original object is reselected into the DC. Example overloads of CDC::SelectObject support the GDI objects: class CDC : public Cobject {... CPen* SelectObject( CPen* ppen); CBrush* SelectObject( CBrush* pbrush); CFont* SelectObject( CFont* pfont); CBitmap* SelectObject( CBitmap* pbitmap); CRgn* SelectObject( CRgn* pregion);... }; Note Palettes are selected into the DC using CDC::SelectPalette. Saving the Deselected Object is important so that it can be restored later. It is a good programming etiquette, to restore the DC to its original state. To ensure that the data in the DC is valid, it must not be left pointing to a local GDI object. Often a DC is shared between functions. Restoring the DC ensures that the next function to receive the DC will receive it in a known state. Example code shows how to create and use a GDI CBrush object:

7 Itay Danielli 7 void CMyView::OnDraw(CDC* pdc) { CBrush mybrush; mybrush.createsolidbrush(rgb(0, 255, 0)); // Save the original brush. CBrush *poldbrush; poldbrush= pdc->selectobject(&mybrush); // Call drawing functions as required. //... // Restore the old pen before exiting. pdc->selectobject(poldbrush); } Windows maintains a set of standard GDI objects for system and program use called stock objects. Stock objects include commonly used pens, brushes, and fonts. Use CDC::SelectStockObject to request predefined fonts, pens, or brushes (or a default palette). Stock objects exist within windows so do not create new ones. GDI category Stock object values Fonts ANSI_FIXED_FONT, ANSI_VAR_FONT, DEVICE_DEFAULT_FONT, OEM_FIXED_FONT, SYSTEM_FONT Pens BLACK_PEN, WHITE_PEN, NULL_PEN. Brushes BLACK_BRUSH, DKGRAY_BRUSH, GRAY_BRUSH, HOLLOW_BRUSH, LTGRAY_BRUSH, NULL_BRUSH, WHITE_BRUSH Note Be sure to explicitly cast the CGdiObject pointer returned by SelectStockObject to a pointer of the proper type. void CmyView::OnDraw(CDC* pdc) { CPen *poldpen; // save pointer to old Pen poldpen = (CPen*)pDC->SelectStockObject(WHITE_PEN);... // Call drawing functions as required pdc->selectobject(poldpen); // Restore the old object before exiting. }

8 Itay Danielli 8 Using GUI objects: Pens - encapsulated in the CPen class, are used to draw lines, curves, and shapes. Pens have three characteristics: style, width, and color. Styles - There are seven pen styles. Width - The width of pen output is described in pixels. Color - Use the RGB macro to create a COLORREF value for the color. Brushes - encapsulated in the CBrush class, are used to fill areas. You can choose from three types. Solid Brushes - Solid brushes require only a COLORREF argument. Hatched Brushes - require a hatch-style index and a COLORREF argument. The standard hatch style, from the windows OS. Example to create a blue hatched brush to fill a polygon. CBrush brush; // Construct and create the brush. brush.createhatchbrush( HS_CROSS, RGB(0,0,255)); pdc->setbrushorg(m_pts[0].x % 8, m_pts[0].y % 8); CBrush* poldbrush= pdc->selectobject(&brush); pdc->polygon(m_pts, GetSize()); pdc->selectobject(poldbrush); Bitmap - is an array of bits that contain data that describes the colors found in a rectangular region on the screen. Working with bitmaps is through the CBitmap class and the CDC bitmap functions. Device-Independent Bitmaps - contains the following color and dimension information: The color format of the device on which the rectangular image was created. The resolution of the device on which the rectangular image was created. The palette for the device on which the image was created. An array of bits that maps red, green, blue (RGB) triplets to pixels in the rectangular image. A data-compression identifier that indicates the data-compression scheme (if any) that is used to reduce the size of the array of bits.

9 Itay Danielli 9 Example creates a bitmap compatible with a specific DC: CRect rect; GetClientRect(&rect); // get the dimensions of the view m_pbitmap = new CBitmap; // create a bitmap compatible with the DC. m_pbitmap->createcompatiblebitmap( pdc, rect.width(), rect.height()); You can also load a bitmap file into your application, although this requires more work. For information, search for "LoadImage" in Visual C++ Help. Region - A region is an area built up from one or more elliptical or polygonal shapes. The CRgn class encapsulates a Windows GDI region. To use regions, also use the clipping functions defined as members of the CDC class. Example code shows how to clip a view area to show elliptical subset of the rectangle: CRgn rgn1, rgn2; // Create the complex, elliptic region. rgn1.createellipticrgn(50,50,200,100); rgn2.createellipticrgn(100,25,50,300); rgn2.combinergn(&rgn1, &rgn2, RGN_OR); pdc->selectcliprgn(&rgn2); // Select it as the clip region CRect rect(0,0,400,400); // Now draw the black rectangle. pdc->selectstockobject(black_brush); pdc->rectangle(&rect); For more information, search for "CRgn" in Visual C++ Help. Plates - The CPalette class encapsulates a Windows color palette. A palette provides an interface between an application and a color output device (such as a display device). The interface allows the application to take full advantage of the color capabilities of the output device without severely interfering with the colors that are displayed by other applications. Windows uses the application's logical palette (a list of needed colors), and the system palette (definitions of available colors) to determine the colors that are used. A CPalette object provides member functions for manipulating the palette referred to by the object. You can construct a CPalette object and use its member functions to create the actual palette, a GDI object, and to manipulate its entries and other properties. For more information, search for "CPalette" in Visual C++ Help.

10 Itay Danielli 10 Fonts: MFC encapsulates fonts in the CFont class. A font is a set of characters of the same typeface (such as Courier), stroke weight (such as bold), and size (such as 10- point). To see an illustration that shows the various characteristics of a font, click this icon. Font types - Fixed-Pitch Fonts - Each cell has the same dimensions, regardless of the width of the character that occupies it. Proportional Fonts - The cells vary in width, depending upon the relative width of the letter (l versus m, for example). Fonts can be stored and drawn by using one of two techniques: Vector fonts - Each font is stored as a mathematical description of the curves that compose each character. Vector fonts are a more compact, flexible method for manipulating font information and they can also be rotated and stretched. Raster fonts - Each font character is stored as a bitmap pattern exactly as it would be displayed on an output device. Because raster-font characters are stored and displayed as is, they can be quickly realized and output. TrueType Fonts - Because Vector fonts are complicated entities, descriptions of them are also complicated. The standard data structure in Windows that is used to describe fonts is TEXTMETRIC data structure. Use the CDC::GetTextMetrics function to retrieve information about the metrics for the currently selected font. For TrueType fonts, CDC::GetOutlineTextMetrics, can be used to fill in an OUTLINETEXTMETRIC structure. The following example shows how set the range for a CScrollView class: TEXTMETRIC tm; pdc->gettextmetrics(&tm); CSize scrollrange; scrollrange.cx = 100; scrollrange.cy = tm.tmheight * GetDocument()->GetSize(); SetScrollSizes( MM_TEXT, scrollrange);

11 Itay Danielli 11 When an application requests the selection of a font into a DC, the font mapper portion of the Windows GDI is responsible for producing the closest match between the requested font and the available fonts. This process is called "font realization." Logical Fonts - A logical font is a description of an ideal font, which may not actually exist on the system. A LOGFONT data type represents a logical font. A physical font is a font that is actually installed on the target system; therefore, it can be displayed. The TEXTMETRIC data type represents it. Using a Non-Stock Font - Using fonts other than the stock fonts can be very helpful when you need a specialized look. To use non-stock fonts first Construct the font object and then Initialize the font by using CFont::CreateFont, CFont::CreateFontIndirect, or CFont::CreatePointFont. Finally select the font into the DC. Example of creation of a font object: CFont font; font.createpointfont( 120, ""); // 12 point, default typeface LOGFONT logfont; font.getlogfont(&logfont); // retrieve specifics about the font. CFont* poldfont = pdc->selectobject(&font); // use font...

12 Itay Danielli 12 Working with mapping modes: All drawing functions called by a Windows-based application draw to logical space. Windows maps or transforms the drawing to physical space. As a result, the application has the advantage of being able to "size" the logical space in a way that is convenient for the problem domain at hand. The term "window" refers to the logical drawing space. The term "viewport" refers to the physical view. The physical view is dependent on the size of your application's client area, and this, in turn, is dependent on the monitor's resolution. Mapping modes: The functions CDC::SetMapMode and CDC::GetMapMode manage the current mapping mode. One view can display concurrently graphical objects that are created with different mapping modes. Windows supports eight mapping modes: Absolute: Positive x is to the right; positive y is down it is the default mode. It follows the conventions of text display: left to right, top to bottom. MM_TEXT Each logical unit is converted to 1 device pixel. MM_LOENGLISH Each logical unit is converted to 0.01 inch. MM_HIENGLISH Each logical unit is converted to inch. MM_LOMETRIC Each logical unit is converted to 0.1 millimeter. MM_HIMETRIC Each logical unit is converted to 0.01 millimeter. MM_TWIPS Each logical unit is converted to 1/20 of a point. (Because a point is 1/72 inch, a twip is 1/1440 inch.) Proportional: Display varies with the relative size of the output window. MM_ANISOTROPIC Allows the x- and y-coordinates to be adjusted independently. The exact shape of the image is not preserved. MM_ISOTROPIC Ensures a 1:1 aspect ratio. The exact shape of an image is preserved.

13 Itay Danielli 13 Set window extents: Tell Windows the size of your logical drawing area. Windows and view ports. Physical coordinates are often called device coordinates or device units. You can use CDC "viewport" and "window" functions and mapping modes to control how the drawing in logical space will be mapped (or transformed) into the physical space of the viewport. CDC::SetWindowExt, CDC::GetWindowExt Set Viewport extents: The other thing you do when setting viewport extents is to adjust the direction of the x- and y-axes. By default, y increases in a downwards direction. This is appropriate for a text or document-based application, but not for a graphics application. You can increase y in an upwards direction by making the second argument to SetViewportExt negative. X, which increases to the right, is probably okay for most applications. CDC::SetViewportExt, CDC::GetViewportExt The default window and viewport extents establish a ratio or scaling factor of 1:1. Note that it is the ratio between extents of the window and the viewport that is important, not the actual values for each. When there is a need to transform between logical and device coordinates. The CDC class provides two functions to perform these transformations, DPtoLP and LPtoDP. Example code to transform device units to logical units: void CMyView::OnMouseMove(UINT nflags, CPoint point) { CClient dc(this); // Create a DC based upon this view. dc.dptolp(&point); // convert the point in to logical units. // do something with it... }

14 Itay Danielli 14 Set window\viewport Origin: CDC::GetWindowOrg, CDC::SetWindowOrg The final step in preparing a suitable drawing environment for your application is to locate the viewport origin. By default, the origin is in the upper-left corner. This location is suitable for a text-based application, but not for a graphics application. In the case of the soccer field, we will locate the origin at the center of the field. And fifth, set the viewport origin. CDC::GetViewportOrg, CDC::SetViewportOrg When you are establishing a logical-drawing space. The default origin is the upper-left corner of the view. Sample code that shows how to set origins and extents in order to display a soccer field. void CFootballView::SetMappingMode(CDC *pdc) { pdc->setmapmode(mm_isotropic); // Preserve aspect ratio // A soccer needs a 10 meter border on all 4 sides.length = 110, WIDTH = 70, BORDER = 10 pdc->setwindowext(length + 2 * BORDER, WIDTH + 2 * BORDER); CRect rect; GetClientRect(&rect); // Get size of viewport // Make y negative to increase y in an upwards direction. pdc->setviewportext(rect.width(), -rect.height()); //Set the origin in the center of the screen by dividing the height and width by 2. pdc->setviewportorg(rect.width() / 2, rect.height() / 2); }

15 Itay Danielli 15 Obtain the client area: You must obtain the size of the client area in order to set viewport extents. For the screen, the client area is reported in pixels. In most cases, this would be the full height and width of the client area. You can obtain the capabilities of your output device through CDC:GetDeviceCaps. Fourth, inform Windows of the portion of the viewport you are going to use. Also in this step, you change the axes directions if required. In particular, you may need to change the y-axis so that it increases in an upwards direction.

16 Itay Danielli 16 Special Visual effects: This section discusses three methods for visual effects: using ROP2 codes to set the raster copying mode. using CRectTracker to handle OLE objects and customize polygons borders. using the BitBlt function to efficiently repaint data to the screen. Using ROP2 codes: In a graphical application, it is common to draw with different graphical objects, and colors, in the same area of the screen. Windows uses the current setting of the ROP attribute of the DC to determine how the colors interact in these areas. For example, a black line can be made to stand out against a black-filled rectangle by drawing the line with an ROP code of R2_XORPEN selected. The ROP attribute of the DC is managed with the CDC::SetRop2 and CDC::GetRop2 functions. * For more information, search for "SetROP2" and "GetROP2" in Visual C++ Help. Using CrectTracker class: The CRectTracker class allows an item to be displayed, moved, and resized in different ways. Although the CRectTracker class is designed to allow the user to interact with OLE items by using a graphical interface, its use is not restricted to OLE-enabled applications. Specific visual effects that CRectTracker provides include the following: CRectTracker borders can be solid or dotted lines. The item can be given a hatched border or overlaid with a hatched pattern to indicate different states of the item. You can place eight resize handles on the outside or the inside border of the item. You can change the orientation of an item during resizing. Using BitBelt: Flicker can occur if the view is rapidly and repeatedly repainted. This flicker is generated by a sequence of alternating view-erase and view-drawing code executing. If your application requires this functionality, then one way to remove the flicker is to perform all painting on an internal bitmap and then transfer the bitmap to the view using a BitBlt operation.

17 Itay Danielli 17 Much of this functionality can be hidden from the application drawing code by overriding the view's OnPaint handler. The OnPaint handler normally sets up CPaintDC and then calls the view's OnDraw function. The intention is to create a memory device context and pass this new context to the OnDraw function. The drawing code uses the new DC; the drawing is simply stored in memory and not sent directly out to the view. When the OnDraw function returns, the OnPaint handler performs a rapid bitmap transfer from the memory DC to the view's DC. To override a view's OnPaint handler 1. Create a memory DC object, compatible with the view. 2. Create a new bitmap object, compatible with the view. 3. Select the bitmap into the CDC object. 4. Call the view's OnDraw function. 5. Select the bitmap into the view's DC. 6. Call the view DC's BitBlt function using the memory DC as the source. 7. Delete the memory DC object and the bitmap object. The following example code shows you how to implement this functionality: void CMyView::OnPaint() { // Generate a paint DC based upon the view. CPaintDC dc(this); // device context for painting pmemdc= new CDC; // Create a compatible memory dc pmemdc->createcompatibledc(&dc); CRect rect; // Get the view's dimensions GetClientRect(&rect); pbitmap = new CBitmap; // Create compatible bitmap. pbitmap->createcompatiblebitmap( &dc, rect.width(), rect.height()); pmemdc->selectobject(pbitmap); OnDraw(pMemDC); // Call the view's OnDraw, passing it the memory DC. dc.selectobject(pbitmap); // do the bitblt to the view from the memory DC. dc.bitblt(0,0,rect.width(), rect.height(), pmemdc, 0, 0, SRCCOPY); pbitmap->deleteobject(); // clean up memory DC and bitmap delete pbitmap; delete pmemdc; }