To manage such distances, the operating system uses a point that is represented by the horizontal and the vertical distances. The Win32 library provides a structure called POINT and defines it as follows: typedef struct tagPOINT
{
LONG x;
LONG y;
} POINT;
The x member variable is the distance from the left border of the screen to the point. The y variable represents the distance from the top border of the screen to the point. Besides the Win32's POINT structure, the Microsoft Foundation Class (MFC) library provides the CPoint class. This provides the same functionality as the POINT structure. As a C++ class, it adds more functionality needed to locate a point. The CPoint::CPoint() default constructor can be used to declare a point variable without specifying its location. If you know the x and y coordinates of a point, you can use the following constructor to create a point: CPoint(int X, int Y);
While a point is used to locate an object on the screen, each window has a size. The size provides two measures related to an object. The size of an object can be represented as follows:
The width of an object, represented as CX, is the distance from its left to its right borders and is provided in pixels. The height of an object, represented as CY is the distance from its top to its bottom borders and is given in pixels. To represent these measures, the Win32 library uses the SIZE structure defined as follows: typedef struct tagSIZE {
int cx;
int cy;
} SIZE;
Besides the Win32's SIZE structure, the MFC provides the CSize class. This class has the same functionality as SIZE but adds features of a C++ class. For example, it provides five constructors that allows you to create a size variable in any way of your choice. The constructors are: CSize(); CSize(int initCX, int initCY); CSize(SIZE initSize); CSize(POINT initPt); CSize(DWORD dwSize); The default constructor allows you to declare a CSize variable whose values are not yet available. The constructor that takes two arguments allows you to provide the width and the height to create a CSize variable. If you want another CSize or a SIZE variables, you can use the CSize(SIZE initSize) constructor to assign its values to your variable. You can use the coordinates of a POINT or a CPoint variable to create and initialize a CSize variable. When we study the effects of the mouse, we will know you can use the coordinates of the position of a mouse pointer. These coordinates can help you define a CSize variable. Besides the constructors, the CSize class is equipped with different member functions that can be used to perform various operations on CSize and SIZE objects. For example, you can add two sizes to get a new size. You can also compare two sizes to find out whether they are the same.
Remember that, to let you create a window, the CWnd class provides a member function named Create and whose syntax is: virtual BOOL Create( LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext = NULL ); When a window displays, it can be identified on the screen by its location with regards to the borders of the monitor. A window can also be identified by its width and height. These characteristics are specified or controlled by the rect argument of the Create() member function of a control's class. This argument is a rectangle that can be created through the Win32 RECT structure. First, you must know how Microsoft Windows represents a rectangle. A rectangle is a geometric figure with four sides or borders: top, right, bottom, and left. A window is also recognized as a rectangle. Therefore, it can be represented as follows:
Microsoft Windows represents items as a coordinate system whose origin (0, 0) is located on the top-left corner of the screen. Everything else is positioned from that point. Therefore:
To represent these distances, the Win32 API provides a structure called RECT and defined as follows: typedef struct _RECT {
LONG left;
LONG top;
LONG right;
LONG bottom;
} RECT, *PRECT;
This structure can be used to control the location of a window on a coordinate system. It can also be used to control or specify the dimensions of a window. To use it, specify a natural numeric value for each of its member variables and pass its variable as the rect argument of the Create() member function. Here is an example: RECT Recto; Recto.left = 100; Recto.top = 120; Recto.right = 620; Recto.bottom = 540; Besides the Win32 RECT structure, the MFC provides an alternative to represent a rectangle on a window. This is done as follows:
Besides the left, top, right, and bottom measures, a window is also recognized for its width and its height. The width is the distance from the left to the right borders of a rectangle. The height is the distance from the top to the bottom borders of a rectangle. To recognize all these measures, the Microsoft Foundation Classes library provides a class called CRect. This class provides various constructors for any way you want to represent a rectangle. The CRect class provides the following constructors: CRect(); CRect(int l, int t, int r, int b); CRect(const RECT& srcRect); CRect(LPCRECT lpSrcRect); CRect(POINT point, SIZE size); CRect(POINT topLeft, POINT bottomRight); The default constructor is used to declare a CRect variable whose values are not known. On the other hand, if you know the left, the top, the right, and the bottom measures of the rectangle, as seen on the RECT structure, you can use them to declare and initialize a rectangle. In the same way, you can assign a CRect, a RECT, a pointer to CRect, or a pointer to a RECT variable to create or initialize a CRect instance. If you do not know or would not specify the location and dimension of a window, you can specify the value of the rect argument as rectDefault. In this case, the compiler would use its own internal value for this argument. |
|
|||||||||||||||
|
|
||||||||||||||||
